Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | WAIT
    | TERN_CONST_HEX of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 16 "p4spec/lib/stf/parser.ml"
  
    | SLASH
    | SETDEFAULT
    | RPAREN
    | REMOVE
    | REGISTER_WRITE
    | REGISTER_RESET
    | REGISTER_READ
    | RBRACKET
    | PACKET_WILDCARD
    | PACKETS
    | PACKET
    | NO_PACKET
    | NE
    | MIRRORING_GET
    | MIRRORING_ADD_MC
    | MIRRORING_ADD
    | MC_NODE_CREATE
    | MC_NODE_ASSOCIATE
    | MC_GROUP_CREATE
    | LT
    | LPAREN
    | LE
    | LBRACKET
    | INT_CONST_HEX of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 44 "p4spec/lib/stf/parser.ml"
  
    | INT_CONST_DEC of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 49 "p4spec/lib/stf/parser.ml"
  
    | INT_CONST_BIN of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 54 "p4spec/lib/stf/parser.ml"
  
    | ID of 
# 25 "p4spec/lib/stf/parser.mly"
      (string)
# 59 "p4spec/lib/stf/parser.ml"
  
    | GT
    | GE
    | EXPECT
    | EXACT
    | EQUAL
    | EQ
    | END
    | DOT
    | DATA_TERN
    | DATA_HEX of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 73 "p4spec/lib/stf/parser.ml"
  
    | DATA_DEC of 
# 27 "p4spec/lib/stf/parser.mly"
      (string)
# 78 "p4spec/lib/stf/parser.ml"
  
    | COMMA
    | COLON
    | CHECK_COUNTER
    | BYTES
    | ALL
    | ADD
  
end

include MenhirBasics

# 16 "p4spec/lib/stf/parser.mly"
  
open Ast

# 95 "p4spec/lib/stf/parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState000 : ('s, _menhir_box_stmts) _menhir_state
    (** State 000.
        Stack shape : <empty>.
        Start symbol: stmts. *)

  | MenhirState002 : (('s, _menhir_box_stmts) _menhir_cell1_SETDEFAULT, _menhir_box_stmts) _menhir_state
    (** State 002.
        Stack shape : SETDEFAULT.
        Start symbol: stmts. *)

  | MenhirState007 : ((('s, _menhir_box_stmts) _menhir_cell1_SETDEFAULT, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 007.
        Stack shape : SETDEFAULT qualified_name.
        Start symbol: stmts. *)

  | MenhirState010 : (((('s, _menhir_box_stmts) _menhir_cell1_SETDEFAULT, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 010.
        Stack shape : SETDEFAULT qualified_name qualified_name.
        Start symbol: stmts. *)

  | MenhirState011 : ((('s, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_LPAREN, _menhir_box_stmts) _menhir_state
    (** State 011.
        Stack shape : qualified_name LPAREN.
        Start symbol: stmts. *)

  | MenhirState014 : (('s, _menhir_box_stmts) _menhir_cell1_ID, _menhir_box_stmts) _menhir_state
    (** State 014.
        Stack shape : ID.
        Start symbol: stmts. *)

  | MenhirState021 : (('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_state
    (** State 021.
        Stack shape : ADD.
        Start symbol: stmts. *)

  | MenhirState026 : (('s, _menhir_box_stmts) _menhir_cell1_arg, _menhir_box_stmts) _menhir_state
    (** State 026.
        Stack shape : arg.
        Start symbol: stmts. *)

  | MenhirState031 : (('s, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE, _menhir_box_stmts) _menhir_state
    (** State 031.
        Stack shape : REGISTER_WRITE.
        Start symbol: stmts. *)

  | MenhirState032 : ((('s, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 032.
        Stack shape : REGISTER_WRITE qualified_name.
        Start symbol: stmts. *)

  | MenhirState033 : (((('s, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_number, _menhir_box_stmts) _menhir_state
    (** State 033.
        Stack shape : REGISTER_WRITE qualified_name number.
        Start symbol: stmts. *)

  | MenhirState035 : (('s, _menhir_box_stmts) _menhir_cell1_REGISTER_RESET, _menhir_box_stmts) _menhir_state
    (** State 035.
        Stack shape : REGISTER_RESET.
        Start symbol: stmts. *)

  | MenhirState036 : ((('s, _menhir_box_stmts) _menhir_cell1_REGISTER_RESET, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 036.
        Stack shape : REGISTER_RESET qualified_name.
        Start symbol: stmts. *)

  | MenhirState037 : (('s, _menhir_box_stmts) _menhir_cell1_REGISTER_READ, _menhir_box_stmts) _menhir_state
    (** State 037.
        Stack shape : REGISTER_READ.
        Start symbol: stmts. *)

  | MenhirState038 : ((('s, _menhir_box_stmts) _menhir_cell1_REGISTER_READ, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 038.
        Stack shape : REGISTER_READ qualified_name.
        Start symbol: stmts. *)

  | MenhirState040 : (('s, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_state
    (** State 040.
        Stack shape : PACKET.
        Start symbol: stmts. *)

  | MenhirState042 : ((('s, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_state
    (** State 042.
        Stack shape : PACKET port.
        Start symbol: stmts. *)

  | MenhirState046 : (((('s, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_cell1_packet_data, _menhir_box_stmts) _menhir_state
    (** State 046.
        Stack shape : PACKET port packet_data.
        Start symbol: stmts. *)

  | MenhirState049 : (('s, _menhir_box_stmts) _menhir_cell1_MIRRORING_GET, _menhir_box_stmts) _menhir_state
    (** State 049.
        Stack shape : MIRRORING_GET.
        Start symbol: stmts. *)

  | MenhirState052 : (('s, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD_MC, _menhir_box_stmts) _menhir_state
    (** State 052.
        Stack shape : MIRRORING_ADD_MC.
        Start symbol: stmts. *)

  | MenhirState053 : ((('s, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD_MC, _menhir_box_stmts) _menhir_cell1_session, _menhir_box_stmts) _menhir_state
    (** State 053.
        Stack shape : MIRRORING_ADD_MC session.
        Start symbol: stmts. *)

  | MenhirState056 : (('s, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD, _menhir_box_stmts) _menhir_state
    (** State 056.
        Stack shape : MIRRORING_ADD.
        Start symbol: stmts. *)

  | MenhirState062 : (('s, _menhir_box_stmts) _menhir_cell1_MC_NODE_CREATE _menhir_cell0_rid, _menhir_box_stmts) _menhir_state
    (** State 062.
        Stack shape : MC_NODE_CREATE rid.
        Start symbol: stmts. *)

  | MenhirState064 : (('s, _menhir_box_stmts) _menhir_cell1_number, _menhir_box_stmts) _menhir_state
    (** State 064.
        Stack shape : number.
        Start symbol: stmts. *)

  | MenhirState066 : (('s, _menhir_box_stmts) _menhir_cell1_MC_NODE_ASSOCIATE, _menhir_box_stmts) _menhir_state
    (** State 066.
        Stack shape : MC_NODE_ASSOCIATE.
        Start symbol: stmts. *)

  | MenhirState070 : (('s, _menhir_box_stmts) _menhir_cell1_MC_GROUP_CREATE, _menhir_box_stmts) _menhir_state
    (** State 070.
        Stack shape : MC_GROUP_CREATE.
        Start symbol: stmts. *)

  | MenhirState072 : (('s, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_state
    (** State 072.
        Stack shape : EXPECT.
        Start symbol: stmts. *)

  | MenhirState073 : ((('s, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_state
    (** State 073.
        Stack shape : EXPECT port.
        Start symbol: stmts. *)

  | MenhirState079 : (((('s, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_cell1_expect_data, _menhir_box_stmts) _menhir_state
    (** State 079.
        Stack shape : EXPECT port expect_data.
        Start symbol: stmts. *)

  | MenhirState084 : (('s, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID, _menhir_box_stmts) _menhir_state
    (** State 084.
        Stack shape : CHECK_COUNTER ID.
        Start symbol: stmts. *)

  | MenhirState098 : ((('s, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID, _menhir_box_stmts) _menhir_cell1_id_or_index _menhir_cell0_count_type _menhir_cell0_logical_cond, _menhir_box_stmts) _menhir_state
    (** State 098.
        Stack shape : CHECK_COUNTER ID id_or_index count_type logical_cond.
        Start symbol: stmts. *)

  | MenhirState100 : (('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_state
    (** State 100.
        Stack shape : ADD.
        Start symbol: stmts. *)

  | MenhirState101 : ((('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 101.
        Stack shape : ADD qualified_name.
        Start symbol: stmts. *)

  | MenhirState103 : (('s, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 103.
        Stack shape : qualified_name.
        Start symbol: stmts. *)

  | MenhirState104 : ((('s, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_COLON, _menhir_box_stmts) _menhir_state
    (** State 104.
        Stack shape : qualified_name COLON.
        Start symbol: stmts. *)

  | MenhirState107 : (((('s, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_COLON, _menhir_box_stmts) _menhir_cell1_number, _menhir_box_stmts) _menhir_state
    (** State 107.
        Stack shape : qualified_name COLON number.
        Start symbol: stmts. *)

  | MenhirState109 : (((('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_priority, _menhir_box_stmts) _menhir_state
    (** State 109.
        Stack shape : ADD qualified_name priority.
        Start symbol: stmts. *)

  | MenhirState111 : ((((('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_priority, _menhir_box_stmts) _menhir_cell1_match_list, _menhir_box_stmts) _menhir_state
    (** State 111.
        Stack shape : ADD qualified_name priority match_list.
        Start symbol: stmts. *)

  | MenhirState112 : ((('s, _menhir_box_stmts) _menhir_cell1_match_list, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_state
    (** State 112.
        Stack shape : match_list qualified_name.
        Start symbol: stmts. *)

  | MenhirState117 : (((('s, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_match_list, _menhir_box_stmts) _menhir_state
    (** State 117.
        Stack shape : ADD qualified_name match_list.
        Start symbol: stmts. *)

  | MenhirState122 : (('s, _menhir_box_stmts) _menhir_cell1_stmt, _menhir_box_stmts) _menhir_state
    (** State 122.
        Stack shape : stmt.
        Start symbol: stmts. *)


and ('s, 'r) _menhir_cell1_arg = 
  | MenhirCell1_arg of 's * ('s, 'r) _menhir_state * (Ast.arg)

and 's _menhir_cell0_count_type = 
  | MenhirCell0_count_type of 's * (Ast.ctr)

and ('s, 'r) _menhir_cell1_expect_data = 
  | MenhirCell1_expect_data of 's * ('s, 'r) _menhir_state * (string option)

and ('s, 'r) _menhir_cell1_id_or_index = 
  | MenhirCell1_id_or_index of 's * ('s, 'r) _menhir_state * (Ast.id_or_index)

and 's _menhir_cell0_logical_cond = 
  | MenhirCell0_logical_cond of 's * (Ast.cond)

and ('s, 'r) _menhir_cell1_match_list = 
  | MenhirCell1_match_list of 's * ('s, 'r) _menhir_state * (Ast.mtch list)

and ('s, 'r) _menhir_cell1_mgid = 
  | MenhirCell1_mgid of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_number = 
  | MenhirCell1_number of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_packet_data = 
  | MenhirCell1_packet_data of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_port = 
  | MenhirCell1_port of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_priority = 
  | MenhirCell1_priority of 's * ('s, 'r) _menhir_state * (int)

and ('s, 'r) _menhir_cell1_qualified_name = 
  | MenhirCell1_qualified_name of 's * ('s, 'r) _menhir_state * (string)

and 's _menhir_cell0_rid = 
  | MenhirCell0_rid of 's * (string)

and ('s, 'r) _menhir_cell1_session = 
  | MenhirCell1_session of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_stmt = 
  | MenhirCell1_stmt of 's * ('s, 'r) _menhir_state * (Ast.stmt)

and ('s, 'r) _menhir_cell1_ADD = 
  | MenhirCell1_ADD of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_CHECK_COUNTER = 
  | MenhirCell1_CHECK_COUNTER of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_COLON = 
  | MenhirCell1_COLON of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_EXPECT = 
  | MenhirCell1_EXPECT of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_ID = 
  | MenhirCell1_ID of 's * ('s, 'r) _menhir_state * 
# 25 "p4spec/lib/stf/parser.mly"
      (string)
# 365 "p4spec/lib/stf/parser.ml"


and 's _menhir_cell0_ID = 
  | MenhirCell0_ID of 's * 
# 25 "p4spec/lib/stf/parser.mly"
      (string)
# 372 "p4spec/lib/stf/parser.ml"


and ('s, 'r) _menhir_cell1_LPAREN = 
  | MenhirCell1_LPAREN of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MC_GROUP_CREATE = 
  | MenhirCell1_MC_GROUP_CREATE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MC_NODE_ASSOCIATE = 
  | MenhirCell1_MC_NODE_ASSOCIATE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MC_NODE_CREATE = 
  | MenhirCell1_MC_NODE_CREATE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MIRRORING_ADD = 
  | MenhirCell1_MIRRORING_ADD of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MIRRORING_ADD_MC = 
  | MenhirCell1_MIRRORING_ADD_MC of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MIRRORING_GET = 
  | MenhirCell1_MIRRORING_GET of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_PACKET = 
  | MenhirCell1_PACKET of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_REGISTER_READ = 
  | MenhirCell1_REGISTER_READ of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_REGISTER_RESET = 
  | MenhirCell1_REGISTER_RESET of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_REGISTER_WRITE = 
  | MenhirCell1_REGISTER_WRITE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_SETDEFAULT = 
  | MenhirCell1_SETDEFAULT of 's * ('s, 'r) _menhir_state

and _menhir_box_stmts = 
  | MenhirBox_stmts of (Ast.stmt list) [@@unboxed]

let _menhir_action_01 =
  fun _1 _3 ->
    (
# 156 "p4spec/lib/stf/parser.mly"
    ( _1, _3 )
# 419 "p4spec/lib/stf/parser.ml"
     : (Ast.action))

let _menhir_action_02 =
  fun _1 ->
    (
# 158 "p4spec/lib/stf/parser.mly"
    ( _1, [] )
# 427 "p4spec/lib/stf/parser.ml"
     : (Ast.action))

let _menhir_action_03 =
  fun _3 ->
    (
# 168 "p4spec/lib/stf/parser.mly"
    ( "add", _3 )
# 435 "p4spec/lib/stf/parser.ml"
     : (Ast.arg))

let _menhir_action_04 =
  fun _1 _3 ->
    (
# 170 "p4spec/lib/stf/parser.mly"
    ( _1, _3 )
# 443 "p4spec/lib/stf/parser.ml"
     : (Ast.arg))

let _menhir_action_05 =
  fun _1 ->
    (
# 162 "p4spec/lib/stf/parser.mly"
    ( [_1] )
# 451 "p4spec/lib/stf/parser.ml"
     : (Ast.arg list))

let _menhir_action_06 =
  fun _1 _3 ->
    (
# 164 "p4spec/lib/stf/parser.mly"
    ( _1 :: _3 )
# 459 "p4spec/lib/stf/parser.ml"
     : (Ast.arg list))

let _menhir_action_07 =
  fun () ->
    (
# 136 "p4spec/lib/stf/parser.mly"
    ( Bytes )
# 467 "p4spec/lib/stf/parser.ml"
     : (Ast.ctr))

let _menhir_action_08 =
  fun () ->
    (
# 138 "p4spec/lib/stf/parser.mly"
    ( Packets )
# 475 "p4spec/lib/stf/parser.ml"
     : (Ast.ctr))

let _menhir_action_09 =
  fun _1 ->
    (
# 202 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 483 "p4spec/lib/stf/parser.ml"
     : (string option))

let _menhir_action_10 =
  fun _1 _2 ->
    (
# 204 "p4spec/lib/stf/parser.mly"
    ( match _1, _2 with
      | Some(x), Some(y) -> Some(x ^ y)
      | None, Some(x) | Some(x), None -> Some(x)
      | None, None -> None )
# 494 "p4spec/lib/stf/parser.ml"
     : (string option))

let _menhir_action_11 =
  fun _1 ->
    (
# 217 "p4spec/lib/stf/parser.mly"
    ( Some(_1) )
# 502 "p4spec/lib/stf/parser.ml"
     : (string option))

let _menhir_action_12 =
  fun () ->
    (
# 219 "p4spec/lib/stf/parser.mly"
    ( Some("*") )
# 510 "p4spec/lib/stf/parser.ml"
     : (string option))

let _menhir_action_13 =
  fun () ->
    (
# 221 "p4spec/lib/stf/parser.mly"
    ( None )
# 518 "p4spec/lib/stf/parser.ml"
     : (string option))

let _menhir_action_14 =
  fun _1 ->
    (
# 194 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 526 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_15 =
  fun _1 ->
    (
# 130 "p4spec/lib/stf/parser.mly"
    ( Id(_1) )
# 534 "p4spec/lib/stf/parser.ml"
     : (Ast.id_or_index))

let _menhir_action_16 =
  fun _1 ->
    (
# 132 "p4spec/lib/stf/parser.mly"
    ( Index(_1) )
# 542 "p4spec/lib/stf/parser.ml"
     : (Ast.id_or_index))

let _menhir_action_17 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 550 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt list))

let _menhir_action_18 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 558 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt list))

let _menhir_action_19 =
  fun () ->
    (
# 142 "p4spec/lib/stf/parser.mly"
    ( Eq )
# 566 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_20 =
  fun () ->
    (
# 144 "p4spec/lib/stf/parser.mly"
    ( Ne )
# 574 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_21 =
  fun () ->
    (
# 146 "p4spec/lib/stf/parser.mly"
    ( Le )
# 582 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_22 =
  fun () ->
    (
# 148 "p4spec/lib/stf/parser.mly"
    ( Lt )
# 590 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_23 =
  fun () ->
    (
# 150 "p4spec/lib/stf/parser.mly"
    ( Ge )
# 598 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_24 =
  fun () ->
    (
# 152 "p4spec/lib/stf/parser.mly"
    ( Gt )
# 606 "p4spec/lib/stf/parser.ml"
     : (Ast.cond))

let _menhir_action_25 =
  fun _1 ->
    (
# 112 "p4spec/lib/stf/parser.mly"
    ( [_1] )
# 614 "p4spec/lib/stf/parser.ml"
     : (Ast.mtch list))

let _menhir_action_26 =
  fun _1 _2 ->
    (
# 114 "p4spec/lib/stf/parser.mly"
    ( _2 :: _1 )
# 622 "p4spec/lib/stf/parser.ml"
     : (Ast.mtch list))

let _menhir_action_27 =
  fun _1 _3 ->
    (
# 118 "p4spec/lib/stf/parser.mly"
    ( (_1, _3) )
# 630 "p4spec/lib/stf/parser.ml"
     : (Ast.mtch))

let _menhir_action_28 =
  fun _1 ->
    (
# 186 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 638 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_29 =
  fun _1 ->
    (
# 90 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 646 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_30 =
  fun _1 ->
    (
# 92 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 654 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_31 =
  fun _1 ->
    (
# 94 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 662 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_32 =
  fun _1 ->
    (
# 96 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 670 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_33 =
  fun _1 ->
    (
# 106 "p4spec/lib/stf/parser.mly"
    ( [_1] )
# 678 "p4spec/lib/stf/parser.ml"
     : (string list))

let _menhir_action_34 =
  fun _1 _2 ->
    (
# 108 "p4spec/lib/stf/parser.mly"
    ( _1 :: _2 )
# 686 "p4spec/lib/stf/parser.ml"
     : (string list))

let _menhir_action_35 =
  fun _1 _3 ->
    (
# 100 "p4spec/lib/stf/parser.mly"
    ( Ast.Slash(_1, _3) )
# 694 "p4spec/lib/stf/parser.ml"
     : (Ast.mtchkind))

let _menhir_action_36 =
  fun _1 ->
    (
# 102 "p4spec/lib/stf/parser.mly"
    ( Ast.Num(_1) )
# 702 "p4spec/lib/stf/parser.ml"
     : (Ast.mtchkind))

let _menhir_action_37 =
  fun _1 ->
    (
# 211 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 710 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_38 =
  fun _1 _2 ->
    (
# 213 "p4spec/lib/stf/parser.mly"
    ( _1 ^ _2 )
# 718 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_39 =
  fun _1 ->
    (
# 225 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 726 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_40 =
  fun _1 ->
    (
# 227 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 734 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_41 =
  fun _1 ->
    (
# 178 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 742 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_42 =
  fun _1 ->
    (
# 182 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 750 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_43 =
  fun _1 ->
    (
# 198 "p4spec/lib/stf/parser.mly"
    ( int_of_string _1 )
# 758 "p4spec/lib/stf/parser.ml"
     : (int))

let _menhir_action_44 =
  fun _1 ->
    (
# 122 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 766 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_45 =
  fun _1 _3 ->
    (
# 124 "p4spec/lib/stf/parser.mly"
    ( _1 ^ "[" ^ _3 ^ "]" )
# 774 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_46 =
  fun _1 _3 ->
    (
# 126 "p4spec/lib/stf/parser.mly"
    ( _1 ^ "." ^ _3 )
# 782 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_47 =
  fun _1 ->
    (
# 190 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 790 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_48 =
  fun _1 ->
    (
# 174 "p4spec/lib/stf/parser.mly"
    ( _1 )
# 798 "p4spec/lib/stf/parser.ml"
     : (string))

let _menhir_action_49 =
  fun _2 _3 _4 _5 ->
    (
# 40 "p4spec/lib/stf/parser.mly"
    ( Add(_2, Some(_3), List.rev _4, _5, None) )
# 806 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_50 =
  fun _2 _3 _4 ->
    (
# 42 "p4spec/lib/stf/parser.mly"
    ( Add(_2, None, List.rev _3, _4, None) )
# 814 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_51 =
  fun _2 _3 _4 _5 _7 ->
    (
# 44 "p4spec/lib/stf/parser.mly"
    ( Add(_2, Some(_3), List.rev _4, _5, Some(_7)) )
# 822 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_52 =
  fun _2 _3 _4 _6 ->
    (
# 46 "p4spec/lib/stf/parser.mly"
    ( Add(_2, None, List.rev _3, _4, Some(_6)) )
# 830 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_53 =
  fun _2 _4 ->
    (
# 48 "p4spec/lib/stf/parser.mly"
    ( CheckCounter(_2, _4, (None, Eq, "0")) )
# 838 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_54 =
  fun _2 _4 _6 _7 _8 ->
    (
# 50 "p4spec/lib/stf/parser.mly"
    ( CheckCounter(_2, _4, (Some(_6), _7, _8)) )
# 846 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_55 =
  fun _2 _3 ->
    (
# 52 "p4spec/lib/stf/parser.mly"
    ( Expect(_2, _3, true) )
# 854 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_56 =
  fun _2 _3 ->
    (
# 54 "p4spec/lib/stf/parser.mly"
    ( Expect(_2, _3, false) )
# 862 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_57 =
  fun _2 ->
    (
# 56 "p4spec/lib/stf/parser.mly"
    ( Expect(_2, None, true) )
# 870 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_58 =
  fun _2 ->
    (
# 58 "p4spec/lib/stf/parser.mly"
    ( Expect(_2, None, false) )
# 878 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_59 =
  fun _2 _3 ->
    (
# 60 "p4spec/lib/stf/parser.mly"
    ( MirroringAdd(_2, _3) )
# 886 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_60 =
  fun _2 _3 ->
    (
# 62 "p4spec/lib/stf/parser.mly"
    ( MirroringAddMc(_2, _3) )
# 894 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_61 =
  fun _2 ->
    (
# 64 "p4spec/lib/stf/parser.mly"
    ( MirroringGet(_2) )
# 902 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_62 =
  fun () ->
    (
# 66 "p4spec/lib/stf/parser.mly"
    ( NoPacket )
# 910 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_63 =
  fun _2 _3 ->
    (
# 68 "p4spec/lib/stf/parser.mly"
    ( Packet(_2, _3) )
# 918 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_64 =
  fun _2 _3 ->
    (
# 70 "p4spec/lib/stf/parser.mly"
    ( SetDefault(_2, _3) )
# 926 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_65 =
  fun _2 ->
    (
# 72 "p4spec/lib/stf/parser.mly"
    ( McGroupCreate(_2) )
# 934 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_66 =
  fun _2 _3 ->
    (
# 74 "p4spec/lib/stf/parser.mly"
    ( McNodeCreate(_2, _3) )
# 942 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_67 =
  fun _2 _3 ->
    (
# 76 "p4spec/lib/stf/parser.mly"
    ( McNodeAssociate(_2, _3) )
# 950 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_68 =
  fun _2 _3 ->
    (
# 78 "p4spec/lib/stf/parser.mly"
    ( RegisterRead(_2, _3) )
# 958 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_69 =
  fun _2 _3 _4 ->
    (
# 80 "p4spec/lib/stf/parser.mly"
    ( RegisterWrite(_2, _3, _4) )
# 966 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_70 =
  fun _2 ->
    (
# 82 "p4spec/lib/stf/parser.mly"
    ( RegisterReset(_2) )
# 974 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_71 =
  fun () ->
    (
# 84 "p4spec/lib/stf/parser.mly"
    ( RemoveAll )
# 982 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_72 =
  fun () ->
    (
# 86 "p4spec/lib/stf/parser.mly"
    ( Wait )
# 990 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt))

let _menhir_action_73 =
  fun _1 ->
    (
# 36 "p4spec/lib/stf/parser.mly"
  ( _1 )
# 998 "p4spec/lib/stf/parser.ml"
     : (Ast.stmt list))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | WAIT ->
        "WAIT"
    | TERN_CONST_HEX _ ->
        "TERN_CONST_HEX"
    | SLASH ->
        "SLASH"
    | SETDEFAULT ->
        "SETDEFAULT"
    | RPAREN ->
        "RPAREN"
    | REMOVE ->
        "REMOVE"
    | REGISTER_WRITE ->
        "REGISTER_WRITE"
    | REGISTER_RESET ->
        "REGISTER_RESET"
    | REGISTER_READ ->
        "REGISTER_READ"
    | RBRACKET ->
        "RBRACKET"
    | PACKET_WILDCARD ->
        "PACKET_WILDCARD"
    | PACKETS ->
        "PACKETS"
    | PACKET ->
        "PACKET"
    | NO_PACKET ->
        "NO_PACKET"
    | NE ->
        "NE"
    | MIRRORING_GET ->
        "MIRRORING_GET"
    | MIRRORING_ADD_MC ->
        "MIRRORING_ADD_MC"
    | MIRRORING_ADD ->
        "MIRRORING_ADD"
    | MC_NODE_CREATE ->
        "MC_NODE_CREATE"
    | MC_NODE_ASSOCIATE ->
        "MC_NODE_ASSOCIATE"
    | MC_GROUP_CREATE ->
        "MC_GROUP_CREATE"
    | LT ->
        "LT"
    | LPAREN ->
        "LPAREN"
    | LE ->
        "LE"
    | LBRACKET ->
        "LBRACKET"
    | INT_CONST_HEX _ ->
        "INT_CONST_HEX"
    | INT_CONST_DEC _ ->
        "INT_CONST_DEC"
    | INT_CONST_BIN _ ->
        "INT_CONST_BIN"
    | ID _ ->
        "ID"
    | GT ->
        "GT"
    | GE ->
        "GE"
    | EXPECT ->
        "EXPECT"
    | EXACT ->
        "EXACT"
    | EQUAL ->
        "EQUAL"
    | EQ ->
        "EQ"
    | END ->
        "END"
    | DOT ->
        "DOT"
    | DATA_TERN ->
        "DATA_TERN"
    | DATA_HEX _ ->
        "DATA_HEX"
    | DATA_DEC _ ->
        "DATA_DEC"
    | COMMA ->
        "COMMA"
    | COLON ->
        "COLON"
    | CHECK_COUNTER ->
        "CHECK_COUNTER"
    | BYTES ->
        "BYTES"
    | ALL ->
        "ALL"
    | ADD ->
        "ADD"

let _menhir_fail : unit -> 'a =
  fun () ->
    Printf.eprintf "Internal failure -- please contact the parser generator's developers.\n%!";
    assert false

include struct
  
  [@@@ocaml.warning "-4-37"]
  
  let _menhir_run_124 : type  ttv_stack. ttv_stack -> _ -> _menhir_box_stmts =
    fun _menhir_stack _v ->
      let _1 = _v in
      let _v = _menhir_action_73 _1 in
      MenhirBox_stmts _v
  
  let rec _menhir_run_123 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_stmt -> _ -> _menhir_box_stmts =
    fun _menhir_stack _v ->
      let MenhirCell1_stmt (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_18 x xs in
      _menhir_goto_list_stmt_ _menhir_stack _v _menhir_s
  
  and _menhir_goto_list_stmt_ : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState122 ->
          _menhir_run_123 _menhir_stack _v
      | MenhirState000 ->
          _menhir_run_124 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  let rec _menhir_run_001 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_72 () in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_stmt : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_stmt (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WAIT ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | SETDEFAULT ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | REMOVE ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | REGISTER_WRITE ->
          _menhir_run_031 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | REGISTER_RESET ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | REGISTER_READ ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | PACKET ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | NO_PACKET ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MIRRORING_GET ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MIRRORING_ADD_MC ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MIRRORING_ADD ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MC_NODE_CREATE ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MC_NODE_ASSOCIATE ->
          _menhir_run_066 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | MC_GROUP_CREATE ->
          _menhir_run_070 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | EXPECT ->
          _menhir_run_072 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | CHECK_COUNTER ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | ADD ->
          _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
      | END ->
          let _v_0 = _menhir_action_17 () in
          _menhir_run_123 _menhir_stack _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_002 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_SETDEFAULT (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState002 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_003 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | INT_CONST_DEC _v_0 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RBRACKET ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_1, _3) = (_v, _v_0) in
                  let _v = _menhir_action_45 _1 _3 in
                  _menhir_goto_qualified_name _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | ADD | CHECK_COUNTER | COLON | DOT | END | EXPECT | ID _ | INT_CONST_BIN _ | INT_CONST_DEC _ | INT_CONST_HEX _ | LPAREN | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | TERN_CONST_HEX _ | WAIT ->
          let _1 = _v in
          let _v = _menhir_action_44 _1 in
          _menhir_goto_qualified_name _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_qualified_name : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState002 ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState007 ->
          _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState031 ->
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState035 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState037 ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState100 ->
          _menhir_run_101 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState101 ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState109 ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState111 ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState117 ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_007 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_SETDEFAULT as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState007
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_008 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_46 _1 _3 in
          _menhir_goto_qualified_name _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_010 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_SETDEFAULT, _menhir_box_stmts) _menhir_cell1_qualified_name as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState010
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_011 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name as 'stack) -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          let _v = _menhir_action_02 _1 in
          _menhir_goto_action _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | ID _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s) in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState011
      | ADD ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s) in
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState011
      | _ ->
          _eRR ()
  
  and _menhir_goto_action : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState007 ->
          _menhir_run_028 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState111 ->
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState117 ->
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_028 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_SETDEFAULT, _menhir_box_stmts) _menhir_cell1_qualified_name -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
      let MenhirCell1_SETDEFAULT (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_64 _2 _3 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_114 : type  ttv_stack. ((((ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_priority, _menhir_box_stmts) _menhir_cell1_match_list -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EQUAL ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v_0 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell1_match_list (_menhir_stack, _, _4) = _menhir_stack in
              let MenhirCell1_priority (_menhir_stack, _, _3) = _menhir_stack in
              let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
              let MenhirCell1_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
              let (_7, _5) = (_v_0, _v) in
              let _v = _menhir_action_51 _2 _3 _4 _5 _7 in
              _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_match_list (_menhir_stack, _, _4) = _menhir_stack in
          let MenhirCell1_priority (_menhir_stack, _, _3) = _menhir_stack in
          let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
          let _5 = _v in
          let _v = _menhir_action_49 _2 _3 _4 _5 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_118 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_match_list -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EQUAL ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v_0 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell1_match_list (_menhir_stack, _, _3) = _menhir_stack in
              let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
              let MenhirCell1_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
              let (_4, _6) = (_v, _v_0) in
              let _v = _menhir_action_52 _2 _3 _4 _6 in
              _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_match_list (_menhir_stack, _, _3) = _menhir_stack in
          let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
          let _4 = _v in
          let _v = _menhir_action_50 _2 _3 _4 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_013 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_s = MenhirState014 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TERN_CONST_HEX _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_HEX _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_DEC _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_BIN _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_015 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_32 _1 in
      _menhir_goto_number _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_number : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState014 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState021 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState032 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState033 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState038 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState062 ->
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState064 ->
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState084 ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState098 ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState104 ->
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState107 ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_019 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_04 _1 _3 in
      _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_arg : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_arg (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState026 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v ->
              _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ADD ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RPAREN ->
          let _1 = _v in
          let _v = _menhir_action_05 _1 in
          _menhir_goto_args _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_020 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_ADD (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_s = MenhirState021 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TERN_CONST_HEX _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_HEX _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_DEC _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_BIN _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_016 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_31 _1 in
      _menhir_goto_number _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_017 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_29 _1 in
      _menhir_goto_number _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_018 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_30 _1 in
      _menhir_goto_number _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_args : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState011 ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState026 ->
          _menhir_run_027 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_023 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_LPAREN -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_LPAREN (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_01 _1 _3 in
      _menhir_goto_action _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_027 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_arg -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_arg (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_06 _1 _3 in
      _menhir_goto_args _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_022 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_03 _3 in
      _menhir_goto_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_033 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE, _menhir_box_stmts) _menhir_cell1_qualified_name as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v_0 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState033
      | INT_CONST_HEX _v_1 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState033
      | INT_CONST_DEC _v_2 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState033
      | INT_CONST_BIN _v_3 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState033
      | _ ->
          _eRR ()
  
  and _menhir_run_034 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_number -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_number (_menhir_stack, _, _3) = _menhir_stack in
      let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
      let MenhirCell1_REGISTER_WRITE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _4 = _v in
      let _v = _menhir_action_69 _2 _3 _4 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_039 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_READ, _menhir_box_stmts) _menhir_cell1_qualified_name -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_qualified_name (_menhir_stack, _, _2) = _menhir_stack in
      let MenhirCell1_REGISTER_READ (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_68 _2 _3 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_064 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v_0 ->
          let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState064
      | INT_CONST_HEX _v_1 ->
          let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState064
      | INT_CONST_DEC _v_2 ->
          let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState064
      | INT_CONST_BIN _v_3 ->
          let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState064
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let _1 = _v in
          let _v = _menhir_action_33 _1 in
          _menhir_goto_number_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_number_list : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState062 ->
          _menhir_run_063 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState064 ->
          _menhir_run_065 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_063 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_MC_NODE_CREATE _menhir_cell0_rid -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_rid (_menhir_stack, _2) = _menhir_stack in
      let MenhirCell1_MC_NODE_CREATE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_66 _2 _3 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_065 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_number -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_number (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_34 _1 _2 in
      _menhir_goto_number_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_086 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_16 _1 in
      _menhir_goto_id_or_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_id_or_index : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PACKETS ->
              let _menhir_stack = MenhirCell1_id_or_index (_menhir_stack, _menhir_s, _v) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let _v = _menhir_action_08 () in
              _menhir_goto_count_type _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | BYTES ->
              let _menhir_stack = MenhirCell1_id_or_index (_menhir_stack, _menhir_s, _v) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let _v = _menhir_action_07 () in
              _menhir_goto_count_type _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
              let MenhirCell0_ID (_menhir_stack, _2) = _menhir_stack in
              let MenhirCell1_CHECK_COUNTER (_menhir_stack, _menhir_s) = _menhir_stack in
              let _4 = _v in
              let _v = _menhir_action_53 _2 _4 in
              _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_count_type : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID, _menhir_box_stmts) _menhir_cell1_id_or_index -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_count_type (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | NE ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_20 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | LT ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_22 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | LE ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_21 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | GT ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_24 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | GE ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_23 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | EQ ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_19 () in
          _menhir_goto_logical_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_logical_cond : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID, _menhir_box_stmts) _menhir_cell1_id_or_index _menhir_cell0_count_type -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_logical_cond (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v_0 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState098
      | INT_CONST_HEX _v_1 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState098
      | INT_CONST_DEC _v_2 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState098
      | INT_CONST_BIN _v_3 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState098
      | _ ->
          _eRR ()
  
  and _menhir_run_099 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_CHECK_COUNTER _menhir_cell0_ID, _menhir_box_stmts) _menhir_cell1_id_or_index _menhir_cell0_count_type _menhir_cell0_logical_cond -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_logical_cond (_menhir_stack, _7) = _menhir_stack in
      let MenhirCell0_count_type (_menhir_stack, _6) = _menhir_stack in
      let MenhirCell1_id_or_index (_menhir_stack, _, _4) = _menhir_stack in
      let MenhirCell0_ID (_menhir_stack, _2) = _menhir_stack in
      let MenhirCell1_CHECK_COUNTER (_menhir_stack, _menhir_s) = _menhir_stack in
      let _8 = _v in
      let _v = _menhir_action_54 _2 _4 _6 _7 _8 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_106 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_COLON as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SLASH ->
          let _menhir_stack = MenhirCell1_number (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState107 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TERN_CONST_HEX _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_HEX _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_DEC _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | INT_CONST_BIN _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | ID _ ->
          let _1 = _v in
          let _v = _menhir_action_36 _1 in
          _menhir_goto_number_or_lpm _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_number_or_lpm : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_COLON -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_COLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_27 _1 _3 in
      _menhir_goto_matcht _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_matcht : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState101 ->
          _menhir_run_110 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState109 ->
          _menhir_run_110 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState111 ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState117 ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_110 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_25 _1 in
      _menhir_goto_match_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_match_list : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState109 ->
          _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState101 ->
          _menhir_run_117 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_111 : type  ttv_stack. ((((ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_priority as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_match_list (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState111
      | _ ->
          _eRR ()
  
  and _menhir_run_117 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD, _menhir_box_stmts) _menhir_cell1_qualified_name as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_match_list (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState117
      | _ ->
          _eRR ()
  
  and _menhir_run_113 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_match_list -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_match_list (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_26 _1 _2 in
      _menhir_goto_match_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_108 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name, _menhir_box_stmts) _menhir_cell1_COLON, _menhir_box_stmts) _menhir_cell1_number -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_number (_menhir_stack, _, _1) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_35 _1 _3 in
      _menhir_goto_number_or_lpm _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_032 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_WRITE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v_0 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState032
      | INT_CONST_HEX _v_1 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState032
      | INT_CONST_DEC _v_2 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState032
      | INT_CONST_BIN _v_3 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState032
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_036 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_RESET as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | DOT ->
          let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_REGISTER_RESET (_menhir_stack, _menhir_s) = _menhir_stack in
          let _2 = _v in
          let _v = _menhir_action_70 _2 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_038 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_REGISTER_READ as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v_0 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState038
      | INT_CONST_HEX _v_1 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState038
      | INT_CONST_DEC _v_2 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState038
      | INT_CONST_BIN _v_3 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState038
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_101 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_ADD as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_menhir_s, _1) = (MenhirState101, _v_0) in
          let _v = _menhir_action_43 _1 in
          let _menhir_stack = MenhirCell1_priority (_menhir_stack, _menhir_s, _v) in
          (match (_tok : MenhirBasics.token) with
          | ID _v_0 ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState109
          | _ ->
              _eRR ())
      | ID _v_2 ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState101
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_103 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | COLON ->
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState103
      | _ ->
          _eRR ()
  
  and _menhir_run_104 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_qualified_name as 'stack) -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_COLON (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState104 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TERN_CONST_HEX _v ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | INT_CONST_HEX _v ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | INT_CONST_DEC _v ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | INT_CONST_BIN _v ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_112 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_match_list as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_qualified_name (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState112
      | DOT ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer
      | COLON ->
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState112
      | _ ->
          _eRR ()
  
  and _menhir_run_029 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ALL ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_71 () in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_031 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_REGISTER_WRITE (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState031 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_035 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_REGISTER_RESET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState035 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_037 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_REGISTER_READ (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState037 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_040 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_PACKET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState040 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DATA_DEC _v ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_041 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_41 _1 in
      _menhir_goto_port _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_port : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState040 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_042 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_PACKET as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_port (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | DATA_HEX _v_0 ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState042
      | DATA_DEC _v_1 ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState042
      | _ ->
          _eRR ()
  
  and _menhir_run_043 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_40 _1 in
      _menhir_goto_packet_datum _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_packet_datum : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState042 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState046 ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState073 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState079 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_045 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_cell1_port as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_37 _1 in
      _menhir_goto_packet_data _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_packet_data : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_cell1_port as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | DATA_HEX _v_0 ->
          let _menhir_stack = MenhirCell1_packet_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState046
      | DATA_DEC _v_1 ->
          let _menhir_stack = MenhirCell1_packet_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState046
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_port (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_PACKET (_menhir_stack, _menhir_s) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_63 _2 _3 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_044 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_39 _1 in
      _menhir_goto_packet_datum _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_047 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_PACKET, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_cell1_packet_data -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_packet_data (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_38 _1 _2 in
      _menhir_goto_packet_data _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_077 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_11 _1 in
      _menhir_goto_expect_datum _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_expect_datum : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState073 ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState079 ->
          _menhir_run_081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_078 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_cell1_port as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_09 _1 in
      _menhir_goto_expect_data _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_expect_data : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_cell1_port as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PACKET_WILDCARD ->
          let _menhir_stack = MenhirCell1_expect_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | EXACT ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_port (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_EXPECT (_menhir_stack, _menhir_s) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_55 _2 _3 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | DATA_TERN ->
          let _menhir_stack = MenhirCell1_expect_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | DATA_HEX _v_0 ->
          let _menhir_stack = MenhirCell1_expect_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState079
      | DATA_DEC _v_1 ->
          let _menhir_stack = MenhirCell1_expect_data (_menhir_stack, _menhir_s, _v) in
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState079
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_port (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_EXPECT (_menhir_stack, _menhir_s) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_56 _2 _3 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_074 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_12 () in
      _menhir_goto_expect_datum _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_076 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_13 () in
      _menhir_goto_expect_datum _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_081 : type  ttv_stack. (((ttv_stack, _menhir_box_stmts) _menhir_cell1_EXPECT, _menhir_box_stmts) _menhir_cell1_port, _menhir_box_stmts) _menhir_cell1_expect_data -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_expect_data (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_10 _1 _2 in
      _menhir_goto_expect_data _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_073 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_EXPECT as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PACKET_WILDCARD ->
          let _menhir_stack = MenhirCell1_port (_menhir_stack, _menhir_s, _v) in
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | EXACT ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EXPECT (_menhir_stack, _menhir_s) = _menhir_stack in
          let _2 = _v in
          let _v = _menhir_action_57 _2 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | DATA_TERN ->
          let _menhir_stack = MenhirCell1_port (_menhir_stack, _menhir_s, _v) in
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | DATA_HEX _v_0 ->
          let _menhir_stack = MenhirCell1_port (_menhir_stack, _menhir_s, _v) in
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState073
      | DATA_DEC _v_1 ->
          let _menhir_stack = MenhirCell1_port (_menhir_stack, _menhir_s, _v) in
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState073
      | ADD | CHECK_COUNTER | END | EXPECT | MC_GROUP_CREATE | MC_NODE_ASSOCIATE | MC_NODE_CREATE | MIRRORING_ADD | MIRRORING_ADD_MC | MIRRORING_GET | NO_PACKET | PACKET | REGISTER_READ | REGISTER_RESET | REGISTER_WRITE | REMOVE | SETDEFAULT | WAIT ->
          let MenhirCell1_EXPECT (_menhir_stack, _menhir_s) = _menhir_stack in
          let _2 = _v in
          let _v = _menhir_action_58 _2 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_048 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_62 () in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_049 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MIRRORING_GET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState049 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_050 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_48 _1 in
      _menhir_goto_session _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_session : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState049 ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState052 ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_051 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_MIRRORING_GET -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_MIRRORING_GET (_menhir_stack, _menhir_s) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_61 _2 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_053 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD_MC as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_session (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v_0 ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState053
      | _ ->
          _eRR ()
  
  and _menhir_run_054 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = _v in
      let _v = _menhir_action_28 _1 in
      _menhir_goto_mgid _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mgid : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState053 ->
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState066 ->
          _menhir_run_067 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_071 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_055 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD_MC, _menhir_box_stmts) _menhir_cell1_session -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_session (_menhir_stack, _, _2) = _menhir_stack in
      let MenhirCell1_MIRRORING_ADD_MC (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_60 _2 _3 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_067 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_MC_NODE_ASSOCIATE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mgid (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _1 = _v_0 in
          let _v = _menhir_action_14 _1 in
          let MenhirCell1_mgid (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_MC_NODE_ASSOCIATE (_menhir_stack, _menhir_s) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_67 _2 _3 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_071 : type  ttv_stack. (ttv_stack, _menhir_box_stmts) _menhir_cell1_MC_GROUP_CREATE -> _ -> _ -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_MC_GROUP_CREATE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_65 _2 in
      _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_057 : type  ttv_stack. ((ttv_stack, _menhir_box_stmts) _menhir_cell1_MIRRORING_ADD as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_stmts) _menhir_state -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_session (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _1 = _v_0 in
          let _v = _menhir_action_42 _1 in
          let MenhirCell1_session (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_MIRRORING_ADD (_menhir_stack, _menhir_s) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_59 _2 _3 in
          _menhir_goto_stmt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_052 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MIRRORING_ADD_MC (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState052 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_056 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MIRRORING_ADD (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState056 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_060 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MC_NODE_CREATE (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _1 = _v in
          let _v = _menhir_action_47 _1 in
          let _menhir_stack = MenhirCell0_rid (_menhir_stack, _v) in
          (match (_tok : MenhirBasics.token) with
          | TERN_CONST_HEX _v_0 ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState062
          | INT_CONST_HEX _v_1 ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState062
          | INT_CONST_DEC _v_2 ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState062
          | INT_CONST_BIN _v_3 ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState062
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_066 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MC_NODE_ASSOCIATE (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState066 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_070 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MC_GROUP_CREATE (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState070 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | INT_CONST_DEC _v ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_072 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_EXPECT (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState072 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DATA_DEC _v ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_082 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_CHECK_COUNTER (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          let _menhir_stack = MenhirCell0_ID (_menhir_stack, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAREN ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | TERN_CONST_HEX _v_0 ->
                  _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState084
              | INT_CONST_HEX _v_1 ->
                  _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState084
              | INT_CONST_DEC _v_2 ->
                  _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState084
              | INT_CONST_BIN _v_3 ->
                  _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState084
              | ID _v_4 ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_menhir_s, _1) = (MenhirState084, _v_4) in
                  let _v = _menhir_action_15 _1 in
                  _menhir_goto_id_or_index _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_100 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_stmts) _menhir_state -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_ADD (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState100 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_stmts =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WAIT ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | SETDEFAULT ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | REMOVE ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | REGISTER_WRITE ->
          _menhir_run_031 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | REGISTER_RESET ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | REGISTER_READ ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | PACKET ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | NO_PACKET ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MIRRORING_GET ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MIRRORING_ADD_MC ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MIRRORING_ADD ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MC_NODE_CREATE ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MC_NODE_ASSOCIATE ->
          _menhir_run_066 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MC_GROUP_CREATE ->
          _menhir_run_070 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | EXPECT ->
          _menhir_run_072 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | CHECK_COUNTER ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | ADD ->
          _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | END ->
          let _v = _menhir_action_17 () in
          _menhir_run_124 _menhir_stack _v
      | _ ->
          _eRR ()
  
end

let stmts =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_stmts v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v