Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | UNREACHABLE
    | UNDERSCORE
    | STAR
    | SLASH
    | SHORTEST
    | SEMI
    | RULE
    | RPAREN
    | RBRACKET
    | QUESTION
    | PARTIAL
    | PARSE
    | LPAREN
    | LBRACKET
    | IDENT of 
# 23 "src/front/parser.mly"
       (string)
# 29 "src/front/parser.ml"
  
    | ERROR
    | EQUAL
    | EOF
    | DOT
    | COMMA
    | COLON
    | BAR
    | AT
    | ACTION of 
# 24 "src/front/parser.mly"
       (Syntax.ocaml_code)
# 42 "src/front/parser.ml"
  
  
end

include MenhirBasics

# 18 "src/front/parser.mly"
  
open Syntax
let mk_re desc position = {desc; position}

# 54 "src/front/parser.ml"

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

  | MenhirState009 : (('s, _menhir_box_parse_filter) _menhir_cell1_wild_symbol, _menhir_box_parse_filter) _menhir_state
    (** State 009.
        Stack shape : wild_symbol.
        Start symbol: parse_filter. *)

  | MenhirState012 : (('s, 'r) _menhir_cell1_positioned_filter_symbol_, 'r) _menhir_state
    (** State 012.
        Stack shape : positioned(filter_symbol).
        Start symbol: <undetermined>. *)

  | MenhirState015 : (('s, 'r) _menhir_cell1_ident _menhir_cell0_LPAREN, 'r) _menhir_state
    (** State 015.
        Stack shape : ident LPAREN.
        Start symbol: <undetermined>. *)

  | MenhirState017 : (('s, 'r) _menhir_cell1_symbol, 'r) _menhir_state
    (** State 017.
        Stack shape : symbol.
        Start symbol: <undetermined>. *)

  | MenhirState028 : ('s, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 028.
        Stack shape : <empty>.
        Start symbol: parse_lexer_definition. *)

  | MenhirState031 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_header, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 031.
        Stack shape : header.
        Start symbol: parse_lexer_definition. *)

  | MenhirState032 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 032.
        Stack shape : RULE.
        Start symbol: parse_lexer_definition. *)

  | MenhirState033 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 033.
        Stack shape : RULE ident.
        Start symbol: parse_lexer_definition. *)

  | MenhirState039 : (((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE _menhir_cell0_positioned_boption_ERROR__ _menhir_cell0_LPAREN, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 039.
        Stack shape : RULE ident list(ident) PARSE positioned(boption(ERROR)) LPAREN.
        Start symbol: parse_lexer_definition. *)

  | MenhirState043 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_positioned_ident_, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 043.
        Stack shape : positioned(ident).
        Start symbol: parse_lexer_definition. *)

  | MenhirState046 : (((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE _menhir_cell0_positioned_boption_ERROR__ _menhir_cell0_startsymbols, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 046.
        Stack shape : RULE ident list(ident) PARSE positioned(boption(ERROR)) startsymbols.
        Start symbol: parse_lexer_definition. *)

  | MenhirState048 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_SHORTEST _menhir_cell0_LBRACKET, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 048.
        Stack shape : SHORTEST LBRACKET.
        Start symbol: parse_lexer_definition. *)

  | MenhirState049 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_BAR, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 049.
        Stack shape : BAR.
        Start symbol: parse_lexer_definition. *)

  | MenhirState051 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_SLASH, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 051.
        Stack shape : SLASH.
        Start symbol: parse_lexer_definition. *)

  | MenhirState053 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_SLASH, _menhir_box_parse_lexer_definition) _menhir_cell1_wild_symbol, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 053.
        Stack shape : SLASH wild_symbol.
        Start symbol: parse_lexer_definition. *)

  | MenhirState056 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_LPAREN, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 056.
        Stack shape : LPAREN.
        Start symbol: parse_lexer_definition. *)

  | MenhirState057 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_LBRACKET, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 057.
        Stack shape : LBRACKET.
        Start symbol: parse_lexer_definition. *)

  | MenhirState061 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq_loop, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 061.
        Stack shape : regseq_loop.
        Start symbol: parse_lexer_definition. *)

  | MenhirState062 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq_loop, _menhir_box_parse_lexer_definition) _menhir_cell1_SEMI, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 062.
        Stack shape : regseq_loop SEMI.
        Start symbol: parse_lexer_definition. *)

  | MenhirState069 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 069.
        Stack shape : ident.
        Start symbol: parse_lexer_definition. *)

  | MenhirState070 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_LBRACKET, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 070.
        Stack shape : ident LBRACKET.
        Start symbol: parse_lexer_definition. *)

  | MenhirState072 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq _menhir_cell0_BAR, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 072.
        Stack shape : regseq BAR.
        Start symbol: parse_lexer_definition. *)

  | MenhirState084 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_regexp, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 084.
        Stack shape : regexp.
        Start symbol: parse_lexer_definition. *)

  | MenhirState088 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_positioned_symbol_, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 088.
        Stack shape : positioned(symbol).
        Start symbol: parse_lexer_definition. *)

  | MenhirState092 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_regexp _menhir_cell0_lookaheads _menhir_cell0_BAR, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 092.
        Stack shape : regexp lookaheads BAR.
        Start symbol: parse_lexer_definition. *)

  | MenhirState102 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_clause, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 102.
        Stack shape : clause.
        Start symbol: parse_lexer_definition. *)

  | MenhirState105 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_clause_group, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 105.
        Stack shape : clause_group.
        Start symbol: parse_lexer_definition. *)

  | MenhirState109 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 109.
        Stack shape : ident ident.
        Start symbol: parse_lexer_definition. *)

  | MenhirState111 : (('s, _menhir_box_parse_lexer_definition) _menhir_cell1_rule, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 111.
        Stack shape : rule.
        Start symbol: parse_lexer_definition. *)

  | MenhirState113 : ((('s, _menhir_box_parse_lexer_definition) _menhir_cell1_header, _menhir_box_parse_lexer_definition) _menhir_cell1_nonempty_list_rule_, _menhir_box_parse_lexer_definition) _menhir_state
    (** State 113.
        Stack shape : header nonempty_list(rule).
        Start symbol: parse_lexer_definition. *)


and ('s, 'r) _menhir_cell1_case_patterns = 
  | MenhirCell1_case_patterns of 's * ('s, 'r) _menhir_state * (Syntax.pattern list)

and ('s, 'r) _menhir_cell1_clause = 
  | MenhirCell1_clause of 's * ('s, 'r) _menhir_state * (Syntax.clause)

and ('s, 'r) _menhir_cell1_clause_group = 
  | MenhirCell1_clause_group of 's * ('s, 'r) _menhir_state * (Syntax.clause_group)

and ('s, 'r) _menhir_cell1_header = 
  | MenhirCell1_header of 's * ('s, 'r) _menhir_state * (Syntax.ocaml_code)

and ('s, 'r) _menhir_cell1_ident = 
  | MenhirCell1_ident of 's * ('s, 'r) _menhir_state * (string) * Lexing.position

and ('s, 'r) _menhir_cell1_list_ident_ = 
  | MenhirCell1_list_ident_ of 's * ('s, 'r) _menhir_state * (string list)

and 's _menhir_cell0_lookaheads = 
  | MenhirCell0_lookaheads of 's * ((Syntax.symbol * Lexing.position) list)

and ('s, 'r) _menhir_cell1_nonempty_list_rule_ = 
  | MenhirCell1_nonempty_list_rule_ of 's * ('s, 'r) _menhir_state * (Syntax.rule list)

and 's _menhir_cell0_positioned_boption_ERROR__ = 
  | MenhirCell0_positioned_boption_ERROR__ of 's * (bool * Lexing.position)

and ('s, 'r) _menhir_cell1_positioned_filter_symbol_ = 
  | MenhirCell1_positioned_filter_symbol_ of 's * ('s, 'r) _menhir_state * (Syntax.filter_symbol * Lexing.position)

and ('s, 'r) _menhir_cell1_positioned_ident_ = 
  | MenhirCell1_positioned_ident_ of 's * ('s, 'r) _menhir_state * (string * Lexing.position)

and ('s, 'r) _menhir_cell1_positioned_symbol_ = 
  | MenhirCell1_positioned_symbol_ of 's * ('s, 'r) _menhir_state * (Syntax.symbol * Lexing.position)

and ('s, 'r) _menhir_cell1_regexp = 
  | MenhirCell1_regexp of 's * ('s, 'r) _menhir_state * (Syntax.regular_expr)

and ('s, 'r) _menhir_cell1_regseq = 
  | MenhirCell1_regseq of 's * ('s, 'r) _menhir_state * (Syntax.regular_expr) * Lexing.position

and ('s, 'r) _menhir_cell1_regseq_loop = 
  | MenhirCell1_regseq_loop of 's * ('s, 'r) _menhir_state * (Syntax.regular_expr list) * Lexing.position

and ('s, 'r) _menhir_cell1_rule = 
  | MenhirCell1_rule of 's * ('s, 'r) _menhir_state * (Syntax.rule)

and 's _menhir_cell0_startsymbols = 
  | MenhirCell0_startsymbols of 's * ((string * Lexing.position) list)

and ('s, 'r) _menhir_cell1_symbol = 
  | MenhirCell1_symbol of 's * ('s, 'r) _menhir_state * (Syntax.symbol) * Lexing.position

and ('s, 'r) _menhir_cell1_wild_symbol = 
  | MenhirCell1_wild_symbol of 's * ('s, 'r) _menhir_state * (Syntax.wild_symbol) * Lexing.position

and ('s, 'r) _menhir_cell1_BAR = 
  | MenhirCell1_BAR of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_BAR = 
  | MenhirCell0_BAR of 's * Lexing.position

and ('s, 'r) _menhir_cell1_LBRACKET = 
  | MenhirCell1_LBRACKET of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position

and 's _menhir_cell0_LBRACKET = 
  | MenhirCell0_LBRACKET of 's * Lexing.position * Lexing.position

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

and 's _menhir_cell0_LPAREN = 
  | MenhirCell0_LPAREN of 's * Lexing.position * Lexing.position

and 's _menhir_cell0_PARSE = 
  | MenhirCell0_PARSE of 's * Lexing.position

and ('s, 'r) _menhir_cell1_RULE = 
  | MenhirCell1_RULE of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_SEMI = 
  | MenhirCell1_SEMI of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_SHORTEST = 
  | MenhirCell1_SHORTEST of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_SLASH = 
  | MenhirCell1_SLASH of 's * ('s, 'r) _menhir_state * Lexing.position

and _menhir_box_parse_lexer_definition = 
  | MenhirBox_parse_lexer_definition of (Syntax.lexer_definition) [@@unboxed]

and _menhir_box_parse_filter = 
  | MenhirBox_parse_filter of (Syntax.filter) [@@unboxed]

let _menhir_action_02 =
  fun () ->
    (
# 134 "<standard.mly>"
    ( false )
# 314 "src/front/parser.ml"
     : (bool))

let _menhir_action_03 =
  fun () ->
    (
# 137 "<standard.mly>"
    ( true )
# 322 "src/front/parser.ml"
     : (bool))

let _menhir_action_04 =
  fun _1 ->
    (
# 103 "src/front/parser.mly"
                    ( Total _1    )
# 330 "src/front/parser.ml"
     : (Syntax.clause_action))

let _menhir_action_05 =
  fun _2 ->
    (
# 104 "src/front/parser.mly"
                    ( Partial _2  )
# 338 "src/front/parser.ml"
     : (Syntax.clause_action))

let _menhir_action_06 =
  fun _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 105 "src/front/parser.mly"
                    ( Unreachable _startpos )
# 347 "src/front/parser.ml"
     : (Syntax.clause_action))

let _menhir_action_07 =
  fun _1 ->
    (
# 88 "src/front/parser.mly"
         ( [{expr=_1; lookaheads=[]}] )
# 355 "src/front/parser.ml"
     : (Syntax.pattern list))

let _menhir_action_08 =
  fun _1 _2 ->
    (
# 89 "src/front/parser.mly"
                    ( [{ expr=_1; lookaheads=_2 }] )
# 363 "src/front/parser.ml"
     : (Syntax.pattern list))

let _menhir_action_09 =
  fun _1 _2 _4 ->
    (
# 90 "src/front/parser.mly"
                                      ( { expr=_1; lookaheads=_2 } :: _4 )
# 371 "src/front/parser.ml"
     : (Syntax.pattern list))

let _menhir_action_10 =
  fun _2 _3 ->
    (
# 99 "src/front/parser.mly"
                                ( {patterns=_2; action=_3} )
# 379 "src/front/parser.ml"
     : (Syntax.clause))

let _menhir_action_11 =
  fun _1 ->
    (
# 94 "src/front/parser.mly"
         ( [_1] )
# 387 "src/front/parser.ml"
     : (Syntax.clause_group))

let _menhir_action_12 =
  fun _3 ->
    (
# 95 "src/front/parser.mly"
                              ( _3 )
# 395 "src/front/parser.ml"
     : (Syntax.clause_group))

let _menhir_action_13 =
  fun () ->
    (
# 151 "src/front/parser.mly"
              ( Dot )
# 403 "src/front/parser.ml"
     : (Syntax.filter_symbol))

let _menhir_action_14 =
  fun () ->
    (
# 152 "src/front/parser.mly"
              ( Skip )
# 411 "src/front/parser.ml"
     : (Syntax.filter_symbol))

let _menhir_action_15 =
  fun _1 ->
    (
# 153 "src/front/parser.mly"
              ( Find _1 )
# 419 "src/front/parser.ml"
     : (Syntax.filter_symbol))

let _menhir_action_16 =
  fun _1 ->
    (
# 71 "src/front/parser.mly"
         ( _1 )
# 427 "src/front/parser.ml"
     : (Syntax.ocaml_code))

let _menhir_action_17 =
  fun () ->
    (
# 73 "src/front/parser.mly"
  ( (Lexing.dummy_pos, "") )
# 435 "src/front/parser.ml"
     : (Syntax.ocaml_code))

let _menhir_action_18 =
  fun _1 ->
    (
# 64 "src/front/parser.mly"
        ( _1      )
# 443 "src/front/parser.ml"
     : (string))

let _menhir_action_19 =
  fun () ->
    (
# 65 "src/front/parser.mly"
        ( "rule"  )
# 451 "src/front/parser.ml"
     : (string))

let _menhir_action_20 =
  fun () ->
    (
# 66 "src/front/parser.mly"
        ( "parse" )
# 459 "src/front/parser.ml"
     : (string))

let _menhir_action_21 =
  fun () ->
    (
# 67 "src/front/parser.mly"
        ( "error" )
# 467 "src/front/parser.ml"
     : (string))

let _menhir_action_22 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 475 "src/front/parser.ml"
     : (Syntax.clause_group))

let _menhir_action_23 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 483 "src/front/parser.ml"
     : (Syntax.clause_group))

let _menhir_action_24 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 491 "src/front/parser.ml"
     : (Syntax.clause_group list))

let _menhir_action_25 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 499 "src/front/parser.ml"
     : (Syntax.clause_group list))

let _menhir_action_26 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 507 "src/front/parser.ml"
     : (string list))

let _menhir_action_27 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 515 "src/front/parser.ml"
     : (string list))

let _menhir_action_28 =
  fun xs ->
    let _1 =
      let x = 
# 241 "<standard.mly>"
    ( xs )
# 524 "src/front/parser.ml"
       in
      
# 188 "<standard.mly>"
    ( x )
# 529 "src/front/parser.ml"
      
    in
    (
# 113 "src/front/parser.mly"
                                                         ( _1 )
# 535 "src/front/parser.ml"
     : ((Syntax.symbol * Lexing.position) list))

let _menhir_action_29 =
  fun () ->
    (
# 145 "<standard.mly>"
    ( [] )
# 543 "src/front/parser.ml"
     : ((Syntax.symbol * Lexing.position) list))

let _menhir_action_30 =
  fun x ->
    (
# 148 "<standard.mly>"
    ( x )
# 551 "src/front/parser.ml"
     : ((Syntax.symbol * Lexing.position) list))

let _menhir_action_31 =
  fun () ->
    (
# 145 "<standard.mly>"
    ( [] )
# 559 "src/front/parser.ml"
     : (Syntax.symbol list))

let _menhir_action_32 =
  fun x ->
    (
# 148 "<standard.mly>"
    ( x )
# 567 "src/front/parser.ml"
     : (Syntax.symbol list))

let _menhir_action_33 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 575 "src/front/parser.ml"
     : ((Syntax.filter_symbol * Lexing.position) list))

let _menhir_action_34 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 583 "src/front/parser.ml"
     : ((Syntax.filter_symbol * Lexing.position) list))

let _menhir_action_35 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 591 "src/front/parser.ml"
     : (Syntax.rule list))

let _menhir_action_36 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 599 "src/front/parser.ml"
     : (Syntax.rule list))

let _menhir_action_37 =
  fun _2_inlined1 ->
    let _1 =
      let _2 = _2_inlined1 in
      let _1 = 
# 123 "<standard.mly>"
    ( None )
# 609 "src/front/parser.ml"
       in
      
# 158 "src/front/parser.mly"
  ( {lhs = _1; rhs = _2} )
# 614 "src/front/parser.ml"
      
    in
    (
# 60 "src/front/parser.mly"
  ( _1 )
# 620 "src/front/parser.ml"
     : (Syntax.filter))

let _menhir_action_38 =
  fun _2_inlined2 x ->
    let _1 =
      let _2 = _2_inlined2 in
      let _1 =
        let x = 
# 196 "<standard.mly>"
    ( x )
# 631 "src/front/parser.ml"
         in
        
# 126 "<standard.mly>"
    ( Some x )
# 636 "src/front/parser.ml"
        
      in
      
# 158 "src/front/parser.mly"
  ( {lhs = _1; rhs = _2} )
# 642 "src/front/parser.ml"
      
    in
    (
# 60 "src/front/parser.mly"
  ( _1 )
# 648 "src/front/parser.ml"
     : (Syntax.filter))

let _menhir_action_39 =
  fun _1 _2 _3 ->
    (
# 55 "src/front/parser.mly"
  ( {header=_1; rules=_2; trailer=_3} )
# 656 "src/front/parser.ml"
     : (Syntax.lexer_definition))

let _menhir_action_40 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 109 "src/front/parser.mly"
    ( (_1, _startpos) )
# 665 "src/front/parser.ml"
     : (bool * Lexing.position))

let _menhir_action_41 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 109 "src/front/parser.mly"
    ( (_1, _startpos) )
# 674 "src/front/parser.ml"
     : (Syntax.filter_symbol * Lexing.position))

let _menhir_action_42 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 109 "src/front/parser.mly"
    ( (_1, _startpos) )
# 683 "src/front/parser.ml"
     : (string * Lexing.position))

let _menhir_action_43 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 109 "src/front/parser.mly"
    ( (_1, _startpos) )
# 692 "src/front/parser.ml"
     : (Syntax.symbol * Lexing.position))

let _menhir_action_44 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 184 "src/front/parser.mly"
              ( match _1 with [x] -> x | xs -> mk_re (Alternative xs) _startpos )
# 701 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_45 =
  fun _2 _startpos__1_ ->
    let _2 =
      let _1 = 
# 123 "<standard.mly>"
    ( None )
# 710 "src/front/parser.ml"
       in
      
# 158 "src/front/parser.mly"
  ( {lhs = _1; rhs = _2} )
# 715 "src/front/parser.ml"
      
    in
    let _startpos = _startpos__1_ in
    (
# 163 "src/front/parser.mly"
  ( mk_re (Filter _2) _startpos )
# 722 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_46 =
  fun _2 _startpos__1_ x ->
    let _2 =
      let _1 =
        let x = 
# 196 "<standard.mly>"
    ( x )
# 732 "src/front/parser.ml"
         in
        
# 126 "<standard.mly>"
    ( Some x )
# 737 "src/front/parser.ml"
        
      in
      
# 158 "src/front/parser.mly"
  ( {lhs = _1; rhs = _2} )
# 743 "src/front/parser.ml"
      
    in
    let _startpos = _startpos__1_ in
    (
# 163 "src/front/parser.mly"
  ( mk_re (Filter _2) _startpos )
# 750 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_47 =
  fun _2 ->
    (
# 131 "src/front/parser.mly"
                 ( _2 )
# 758 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_48 =
  fun _2 _endpos__0_ ->
    let _1 =
      let _1 = 
# 123 "<standard.mly>"
    ( None )
# 767 "src/front/parser.ml"
       in
      
# 127 "src/front/parser.mly"
                                 ( _1 )
# 772 "src/front/parser.ml"
      
    in
    let _startpos__1_ = _endpos__0_ in
    let _startpos = _startpos__1_ in
    (
# 132 "src/front/parser.mly"
                      ( mk_re (Atom (_1, _2, Utils.Usage.new_mark ())) _startpos )
# 780 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_49 =
  fun _2 _startpos_x_ x ->
    let _1 =
      let _1 =
        let x = 
# 196 "<standard.mly>"
    ( x )
# 790 "src/front/parser.ml"
         in
        
# 126 "<standard.mly>"
    ( Some x )
# 795 "src/front/parser.ml"
        
      in
      
# 127 "src/front/parser.mly"
                                 ( _1 )
# 801 "src/front/parser.ml"
      
    in
    let _startpos__1_ = _startpos_x_ in
    let _startpos = _startpos__1_ in
    (
# 132 "src/front/parser.mly"
                      ( mk_re (Atom (_1, _2, Utils.Usage.new_mark ())) _startpos )
# 809 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_50 =
  fun _3 _endpos__0_ ->
    let _1 =
      let _1 = 
# 123 "<standard.mly>"
    ( None )
# 818 "src/front/parser.ml"
       in
      
# 127 "src/front/parser.mly"
                                 ( _1 )
# 823 "src/front/parser.ml"
      
    in
    let _startpos__1_ = _endpos__0_ in
    let _startpos = _startpos__1_ in
    (
# 134 "src/front/parser.mly"
  ( let mark, policy, expr = match _3.desc with
        | Reduce {capture=None; mark; policy=Shortest; expr} ->
           (mark, Longest, expr)
        | _ -> (Utils.Usage.new_mark (), Shortest, _3)
    in
    mk_re (Reduce {capture=_1; mark; expr; policy}) _startpos
  )
# 837 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_51 =
  fun _3 _startpos_x_ x ->
    let _1 =
      let _1 =
        let x = 
# 196 "<standard.mly>"
    ( x )
# 847 "src/front/parser.ml"
         in
        
# 126 "<standard.mly>"
    ( Some x )
# 852 "src/front/parser.ml"
        
      in
      
# 127 "src/front/parser.mly"
                                 ( _1 )
# 858 "src/front/parser.ml"
      
    in
    let _startpos__1_ = _startpos_x_ in
    let _startpos = _startpos__1_ in
    (
# 134 "src/front/parser.mly"
  ( let mark, policy, expr = match _3.desc with
        | Reduce {capture=None; mark; policy=Shortest; expr} ->
           (mark, Longest, expr)
        | _ -> (Utils.Usage.new_mark (), Shortest, _3)
    in
    mk_re (Reduce {capture=_1; mark; expr; policy}) _startpos
  )
# 872 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_52 =
  fun _endpos__0_ ->
    let _startpos = _endpos__0_ in
    (
# 174 "src/front/parser.mly"
              ( mk_re (Concat []) _startpos )
# 881 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_53 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 175 "src/front/parser.mly"
              ( match _1 with [x] -> x | xs  -> mk_re (Concat (List.rev xs)) _startpos )
# 890 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_54 =
  fun _1 _2 ->
    (
# 167 "src/front/parser.mly"
                          ( _2 :: _1 )
# 898 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_55 =
  fun _1 ->
    (
# 168 "src/front/parser.mly"
                          ( [_1] )
# 906 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_56 =
  fun _1 ->
    (
# 169 "src/front/parser.mly"
                          ( [_1] )
# 914 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_57 =
  fun _1 _3 ->
    (
# 170 "src/front/parser.mly"
                          ( _3 :: _1 )
# 922 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_58 =
  fun _1 ->
    (
# 179 "src/front/parser.mly"
                         ( [_1] )
# 930 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_59 =
  fun _1 _3 ->
    (
# 180 "src/front/parser.mly"
                         ( _1 :: _3 )
# 938 "src/front/parser.ml"
     : (Syntax.regular_expr list))

let _menhir_action_60 =
  fun _1 ->
    (
# 144 "src/front/parser.mly"
                  ( _1 )
# 946 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_61 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 145 "src/front/parser.mly"
                  ( mk_re (Repetition {expr=_1; policy=Shortest}) _startpos )
# 955 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_62 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 146 "src/front/parser.mly"
                  ( mk_re (Repetition {expr=_1; policy=Longest}) _startpos )
# 964 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_63 =
  fun _1 _startpos__1_ ->
    let _startpos = _startpos__1_ in
    (
# 147 "src/front/parser.mly"
                  ( mk_re (Alternative [_1; mk_re (Concat []) _startpos]) _startpos )
# 973 "src/front/parser.ml"
     : (Syntax.regular_expr))

let _menhir_action_64 =
  fun args clauses error name startsymbols ->
    (
# 84 "src/front/parser.mly"
  ( {startsymbols; error; name; args; clauses} )
# 981 "src/front/parser.ml"
     : (Syntax.rule))

let _menhir_action_65 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 989 "src/front/parser.ml"
     : ((string * Lexing.position) list))

let _menhir_action_66 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 997 "src/front/parser.ml"
     : ((string * Lexing.position) list))

let _menhir_action_67 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 1005 "src/front/parser.ml"
     : ((Syntax.symbol * Lexing.position) list))

let _menhir_action_68 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 1013 "src/front/parser.ml"
     : ((Syntax.symbol * Lexing.position) list))

let _menhir_action_69 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 1021 "src/front/parser.ml"
     : (Syntax.symbol list))

let _menhir_action_70 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 1029 "src/front/parser.ml"
     : (Syntax.symbol list))

let _menhir_action_71 =
  fun () ->
    (
# 77 "src/front/parser.mly"
            ( [] )
# 1037 "src/front/parser.ml"
     : ((string * Lexing.position) list))

let _menhir_action_72 =
  fun _2 ->
    (
# 78 "src/front/parser.mly"
                                                          ( _2 )
# 1045 "src/front/parser.ml"
     : ((string * Lexing.position) list))

let _menhir_action_73 =
  fun _1 ->
    (
# 117 "src/front/parser.mly"
                                            ( Name _1 )
# 1053 "src/front/parser.ml"
     : (Syntax.symbol))

let _menhir_action_74 =
  fun _1 xs ->
    let _3 = 
# 241 "<standard.mly>"
    ( xs )
# 1061 "src/front/parser.ml"
     in
    (
# 118 "src/front/parser.mly"
                                            ( Apply (_1, _3) )
# 1066 "src/front/parser.ml"
     : (Syntax.symbol))

let _menhir_action_75 =
  fun () ->
    (
# 122 "src/front/parser.mly"
         ( None )
# 1074 "src/front/parser.ml"
     : (Syntax.wild_symbol))

let _menhir_action_76 =
  fun _1 ->
    (
# 123 "src/front/parser.mly"
         ( Some _1 )
# 1082 "src/front/parser.ml"
     : (Syntax.wild_symbol))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | UNREACHABLE ->
        "UNREACHABLE"
    | UNDERSCORE ->
        "UNDERSCORE"
    | STAR ->
        "STAR"
    | SLASH ->
        "SLASH"
    | SHORTEST ->
        "SHORTEST"
    | SEMI ->
        "SEMI"
    | RULE ->
        "RULE"
    | RPAREN ->
        "RPAREN"
    | RBRACKET ->
        "RBRACKET"
    | QUESTION ->
        "QUESTION"
    | PARTIAL ->
        "PARTIAL"
    | PARSE ->
        "PARSE"
    | LPAREN ->
        "LPAREN"
    | LBRACKET ->
        "LBRACKET"
    | IDENT _ ->
        "IDENT"
    | ERROR ->
        "ERROR"
    | EQUAL ->
        "EQUAL"
    | EOF ->
        "EOF"
    | DOT ->
        "DOT"
    | COMMA ->
        "COMMA"
    | COLON ->
        "COLON"
    | BAR ->
        "BAR"
    | AT ->
        "AT"
    | ACTION _ ->
        "ACTION"

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_114 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_header, _menhir_box_parse_lexer_definition) _menhir_cell1_nonempty_list_rule_ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let MenhirCell1_nonempty_list_rule_ (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_header (_menhir_stack, _, _1) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_39 _1 _2 _3 in
          MenhirBox_parse_lexer_definition _v
      | _ ->
          _eRR ()
  
  let _menhir_goto_parse_filter : type  ttv_stack. ttv_stack -> _ -> _menhir_box_parse_filter =
    fun _menhir_stack _v ->
      MenhirBox_parse_filter _v
  
  let _menhir_run_023 : type  ttv_stack. (ttv_stack, _menhir_box_parse_filter) _menhir_cell1_wild_symbol -> _ -> _ -> _menhir_box_parse_filter =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let MenhirCell1_wild_symbol (_menhir_stack, _, x, _) = _menhir_stack in
          let _2_inlined2 = _v in
          let _v = _menhir_action_38 _2_inlined2 x in
          _menhir_goto_parse_filter _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_run_026 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_filter =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let _2_inlined1 = _v in
          let _v = _menhir_action_37 _2_inlined1 in
          _menhir_goto_parse_filter _menhir_stack _v
      | _ ->
          _eRR ()
  
  let rec _menhir_run_001 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | STAR ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _startpos__1_ = _startpos in
          let _v = _menhir_action_14 () in
          _menhir_goto_filter_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | ACTION _ | AT | BAR | COLON | DOT | EOF | ERROR | IDENT _ | PARSE | PARTIAL | RBRACKET | RPAREN | RULE | SEMI | SLASH | UNDERSCORE | UNREACHABLE ->
          let _startpos__1_ = _startpos in
          let _v = _menhir_action_75 () in
          _menhir_goto_wild_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_filter_symbol : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_41 _1 _startpos__1_ in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState012
      | RULE ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState012
      | PARSE ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState012
      | IDENT _v_0 ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState012
      | ERROR ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState012
      | DOT ->
          let _menhir_stack = MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState012
      | ACTION _ | AT | BAR | EOF | PARTIAL | RBRACKET | RPAREN | SEMI | SLASH | UNREACHABLE ->
          let x = _v in
          let _v = _menhir_action_33 x in
          _menhir_goto_nonempty_list_positioned_filter_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_003 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_19 () in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_ident : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState000 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState009 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState012 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState015 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState017 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState051 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState053 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState069 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState084 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState088 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState032 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState039 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState043 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState049 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState062 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState033 ->
          _menhir_run_109 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState109 ->
          _menhir_run_109 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_014 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer
      | ACTION _ | AT | BAR | COLON | COMMA | DOT | EOF | ERROR | IDENT _ | PARSE | PARTIAL | QUESTION | RBRACKET | RPAREN | RULE | SEMI | SLASH | STAR | UNDERSCORE | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_73 _1 in
          _menhir_goto_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_015 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ident -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) in
      let _menhir_s = MenhirState015 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RPAREN ->
          let _v = _menhir_action_31 () in
          _menhir_goto_loption_separated_nonempty_list_COMMA_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_004 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_20 () in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_005 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_18 _1 in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_006 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_21 () in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_loption_separated_nonempty_list_COMMA_symbol__ : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ident _menhir_cell0_LPAREN -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LPAREN (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_ident (_menhir_stack, _menhir_s, _1, _startpos__1_) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_74 _1 xs in
      _menhir_goto_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_symbol : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState000 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState009 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState012 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState049 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState051 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState053 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState062 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState069 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState015 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState017 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState084 ->
          _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState088 ->
          _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_011 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_76 _1 in
      _menhir_goto_wild_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_wild_symbol : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState000 ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState009 ->
          _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState012 ->
          _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState053 ->
          _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState051 ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState049 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState062 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState069 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_008 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_filter) _menhir_state -> _ -> _menhir_box_parse_filter =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_wild_symbol (_menhir_stack, _menhir_s, _v, _startpos) in
          let _menhir_s = MenhirState009 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | DOT | EOF | ERROR | IDENT _ | PARSE | RULE | UNDERSCORE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_15 _1 in
          _menhir_goto_filter_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_007 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_13 () in
      _menhir_goto_filter_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_010 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_15 _1 in
      _menhir_goto_filter_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_052 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_SLASH as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_wild_symbol (_menhir_stack, _menhir_s, _v, _startpos) in
          let _menhir_s = MenhirState053 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | ACTION _ | AT | BAR | DOT | ERROR | IDENT _ | PARSE | PARTIAL | RBRACKET | RPAREN | RULE | SEMI | SLASH | UNDERSCORE | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_15 _1 in
          _menhir_goto_filter_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_058 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      _menhir_act_goto_48 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _v _startpos
  
  and _menhir_act_goto_48 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _2 _startpos__2_ ->
      match _menhir_s with
      | MenhirState049 ->
          let MenhirCell1_BAR (_, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState056 ->
          let MenhirCell1_LPAREN (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState057 ->
          let MenhirCell1_LBRACKET (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState062 ->
          let MenhirCell1_SEMI (_, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState070 ->
          let MenhirCell1_LBRACKET (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState072 ->
          let MenhirCell0_BAR (_, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState092 ->
          let MenhirCell0_BAR (_, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_48 _2 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_064 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | STAR ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | STAR ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos__1_, _1) = (_startpos, _v) in
              let _v = _menhir_action_62 _1 _startpos__1_ in
              _menhir_goto_regterm _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
          | ACTION _ | AT | BAR | PARTIAL | RBRACKET | RPAREN | SEMI | SLASH | UNREACHABLE ->
              let (_startpos__1_, _1) = (_startpos, _v) in
              let _v = _menhir_action_61 _1 _startpos__1_ in
              _menhir_goto_regterm _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | QUESTION ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_63 _1 _startpos__1_ in
          _menhir_goto_regterm _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | ACTION _ | AT | BAR | PARTIAL | RBRACKET | RPAREN | SEMI | SLASH | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_60 _1 in
          _menhir_goto_regterm _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_regterm : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState049 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState062 ->
          _menhir_run_063 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_059 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_55 _1 in
      _menhir_goto_regseq_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_regseq_loop : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SLASH ->
          let _menhir_stack = MenhirCell1_regseq_loop (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState061
      | SEMI ->
          let _menhir_stack = MenhirCell1_regseq_loop (_menhir_stack, _menhir_s, _v, _startpos) in
          let _menhir_s = MenhirState061 in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell1_SEMI (_menhir_stack, _menhir_s, _endpos) in
          let _menhir_s = MenhirState062 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LPAREN ->
              _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LBRACKET ->
              _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | ACTION _ | AT | BAR | PARTIAL | RBRACKET | RPAREN | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_53 _1 _startpos__1_ in
          _menhir_goto_regseq _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_051 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState051 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | DOT ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_050 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_75 () in
      _menhir_goto_wild_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_056 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos, _endpos) in
      let _menhir_s = MenhirState056 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SLASH ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LPAREN ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LBRACKET ->
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BAR | RPAREN ->
          _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_057 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) in
      let _menhir_s = MenhirState057 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SLASH ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LPAREN ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LBRACKET ->
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BAR | RBRACKET ->
          _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_reduce_52 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok ->
      let _endpos__0_ = _endpos in
      let _v = _menhir_action_52 _endpos__0_ in
      _menhir_goto_regseq _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_regseq : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | BAR ->
          let _menhir_stack = MenhirCell1_regseq (_menhir_stack, _menhir_s, _v, _startpos) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _endpos) in
          let _menhir_s = MenhirState072 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | SLASH ->
              _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LPAREN ->
              _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LBRACKET ->
              _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ACTION _ | AT | BAR | PARTIAL | RBRACKET | RPAREN | UNREACHABLE ->
              _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
          | _ ->
              _eRR ())
      | ACTION _ | AT | PARTIAL | RBRACKET | RPAREN | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_58 _1 in
          _menhir_goto_regsum_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_regsum_loop : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState049 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_060 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_44 _1 _startpos__1_ in
      _menhir_goto_regexp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_regexp : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState070 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState057 ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState056 ->
          _menhir_run_081 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState049 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_075 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_LBRACKET -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACKET (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
          let _3 = _v in
          let _v = _menhir_action_51 _3 _startpos_x_ x in
          _menhir_goto_regleaf _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_x_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_regleaf : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
  
  and _menhir_run_079 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_LBRACKET -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__2_, _) = _menhir_stack in
          _menhir_act_goto_50 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _startpos__2_ _v
      | _ ->
          _eRR ()
  
  and _menhir_act_goto_50 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok _startpos__2_ _3 ->
      match _menhir_s with
      | MenhirState049 ->
          let MenhirCell1_BAR (_, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState056 ->
          let MenhirCell1_LPAREN (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState057 ->
          let MenhirCell1_LBRACKET (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState062 ->
          let MenhirCell1_SEMI (_, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState070 ->
          let MenhirCell1_LBRACKET (_, _, _, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState072 ->
          let MenhirCell0_BAR (_, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | MenhirState092 ->
          let MenhirCell0_BAR (_, _endpos__0_) = _menhir_stack in
          let _v = _menhir_action_50 _3 _endpos__0_ in
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__2_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_081 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_LPAREN -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_, _) = _menhir_stack in
          let _2 = _v in
          let _v = _menhir_action_47 _2 in
          _menhir_goto_regleaf _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_083 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | AT ->
          let _menhir_stack = MenhirCell1_regexp (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState084 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ACTION _ | BAR | PARTIAL | UNREACHABLE ->
              let _v = _menhir_action_29 () in
              _menhir_goto_loption_separated_nonempty_list_COMMA_positioned_symbol___ _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | _ ->
              _eRR ())
      | ACTION _ | PARTIAL | UNREACHABLE ->
          let _1 = _v in
          let _v = _menhir_action_07 _1 in
          _menhir_goto_case_patterns _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_loption_separated_nonempty_list_COMMA_positioned_symbol___ : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regexp -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let xs = _v in
      let _v = _menhir_action_28 xs in
      match (_tok : MenhirBasics.token) with
      | BAR ->
          let _menhir_stack = MenhirCell0_lookaheads (_menhir_stack, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _endpos) in
          let _menhir_s = MenhirState092 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | SLASH ->
              _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LPAREN ->
              _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LBRACKET ->
              _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ACTION _ | AT | BAR | PARTIAL | UNREACHABLE ->
              _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
          | _ ->
              _eRR ())
      | ACTION _ | PARTIAL | UNREACHABLE ->
          let MenhirCell1_regexp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          let _2 = _v in
          let _v = _menhir_action_08 _1 _2 in
          _menhir_goto_case_patterns _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_case_patterns : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState092 ->
          _menhir_run_093 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState049 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_093 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regexp _menhir_cell0_lookaheads _menhir_cell0_BAR -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_BAR (_menhir_stack, _) = _menhir_stack in
      let MenhirCell0_lookaheads (_menhir_stack, _2) = _menhir_stack in
      let MenhirCell1_regexp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      let _4 = _v in
      let _v = _menhir_action_09 _1 _2 _4 in
      _menhir_goto_case_patterns _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_094 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_BAR as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_case_patterns (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | UNREACHABLE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _startpos__1_ = _startpos in
          let _v = _menhir_action_06 _startpos__1_ in
          _menhir_goto_case_action _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | PARTIAL ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ACTION _v_1 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let _2 = _v_1 in
              let _v = _menhir_action_05 _2 in
              _menhir_goto_case_action _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | _ ->
              _eRR ())
      | ACTION _v_3 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _1 = _v_3 in
          let _v = _menhir_action_04 _1 in
          _menhir_goto_case_action _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_case_action : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_BAR, _menhir_box_parse_lexer_definition) _menhir_cell1_case_patterns -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_case_patterns (_menhir_stack, _, _2) = _menhir_stack in
      let MenhirCell1_BAR (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_10 _2 _3 in
      _menhir_goto_clause _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_clause : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState048 ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState102 ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState046 ->
          _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState105 ->
          _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_102 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_clause (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | BAR ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState102
      | RBRACKET ->
          let _v_0 = _menhir_action_22 () in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0
      | _ ->
          _eRR ()
  
  and _menhir_run_049 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_BAR (_menhir_stack, _menhir_s, _endpos) in
      let _menhir_s = MenhirState049 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SLASH ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LPAREN ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LBRACKET ->
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ACTION _ | AT | BAR | PARTIAL | UNREACHABLE ->
          _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_103 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_clause -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_clause (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_23 x xs in
      _menhir_goto_list_clause_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_list_clause_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState048 ->
          _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState102 ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_100 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_SHORTEST _menhir_cell0_LBRACKET -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LBRACKET (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_SHORTEST (_menhir_stack, _menhir_s) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_12 _3 in
      _menhir_goto_clause_group _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_clause_group : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_clause_group (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SHORTEST ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
      | BAR ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
      | ACTION _ | EOF | RULE ->
          let _v_0 = _menhir_action_24 () in
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_047 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_SHORTEST (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LBRACKET ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_LBRACKET (_menhir_stack, _startpos, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | BAR ->
              _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState048
          | RBRACKET ->
              let _v = _menhir_action_22 () in
              _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_106 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_clause_group -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_clause_group (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_25 x xs in
      _menhir_goto_list_clause_group_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_list_clause_group_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState046 ->
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState105 ->
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_104 : type  ttv_stack. (((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE _menhir_cell0_positioned_boption_ERROR__ _menhir_cell0_startsymbols -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_startsymbols (_menhir_stack, startsymbols) = _menhir_stack in
      let MenhirCell0_positioned_boption_ERROR__ (_menhir_stack, error) = _menhir_stack in
      let MenhirCell0_PARSE (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_list_ident_ (_menhir_stack, _, args) = _menhir_stack in
      let MenhirCell1_ident (_menhir_stack, _, name, _) = _menhir_stack in
      let MenhirCell1_RULE (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let clauses = _v in
      let _v = _menhir_action_64 args clauses error name startsymbols in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          let _menhir_stack = MenhirCell1_rule (_menhir_stack, _menhir_s, _v) in
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState111
      | ACTION _ | EOF ->
          let x = _v in
          let _v = _menhir_action_35 x in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_032 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_RULE (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState032 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_rule_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState111 ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState031 ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_112 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_rule -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_rule (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_36 x xs in
      _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_113 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_header as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_nonempty_list_rule_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | ACTION _v_0 ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState113
      | EOF ->
          let _v_1 = _menhir_action_17 () in
          _menhir_run_114 _menhir_stack _v_1 _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_029 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    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_16 _1 in
      _menhir_goto_header _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_header : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState028 ->
          _menhir_run_031 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState113 ->
          _menhir_run_114 _menhir_stack _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_031 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_header (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState031
      | _ ->
          _eRR ()
  
  and _menhir_run_107 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_11 _1 in
      _menhir_goto_clause_group _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_073 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq _menhir_cell0_BAR -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_BAR (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_regseq (_menhir_stack, _menhir_s, _1, _startpos__1_) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_59 _1 _3 in
      _menhir_goto_regsum_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_063 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq_loop, _menhir_box_parse_lexer_definition) _menhir_cell1_SEMI -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_SEMI (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_regseq_loop (_menhir_stack, _menhir_s, _1, _startpos__1_) = _menhir_stack in
      let _3 = _v in
      let _v = _menhir_action_57 _1 _3 in
      _menhir_goto_regseq_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_077 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_ident -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ident (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_49 _2 _startpos_x_ x in
      _menhir_goto_regleaf _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_x_ _v _menhir_s _tok
  
  and _menhir_run_016 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_symbol (_menhir_stack, _menhir_s, _v, _startpos) in
          let _menhir_s = MenhirState017 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RPAREN ->
          let x = _v in
          let _v = _menhir_action_69 x in
          _menhir_goto_separated_nonempty_list_COMMA_symbol_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_symbol_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState017 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState015 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_018 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_symbol -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_symbol (_menhir_stack, _menhir_s, x, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_70 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_symbol_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_019 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ident _menhir_cell0_LPAREN -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let x = _v in
      let _v = _menhir_action_32 x in
      _menhir_goto_loption_separated_nonempty_list_COMMA_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v
  
  and _menhir_run_085 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_43 _1 _startpos__1_ in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_positioned_symbol_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState088 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | ACTION _ | BAR | PARTIAL | UNREACHABLE ->
          let x = _v in
          let _v = _menhir_action_67 x in
          _menhir_goto_separated_nonempty_list_COMMA_positioned_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_positioned_symbol__ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState084 ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState088 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_086 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regexp -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let x = _v in
      let _v = _menhir_action_30 x in
      _menhir_goto_loption_separated_nonempty_list_COMMA_positioned_symbol___ _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_089 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_positioned_symbol_ -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_positioned_symbol_ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_68 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_positioned_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_033 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState033
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState033
      | IDENT _v_0 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState033
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState033
      | EQUAL ->
          let _v_1 = _menhir_action_26 () in
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState033
      | _ ->
          _eRR ()
  
  and _menhir_run_034 : type  ttv_stack. (((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_list_ident_ (_menhir_stack, _menhir_s, _v) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | PARSE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_PARSE (_menhir_stack, _startpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ERROR ->
              let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let _startpos__1_ = _startpos_0 in
              let _v = _menhir_action_03 () in
              _menhir_goto_boption_ERROR_ _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _tok
          | ACTION _ | BAR | EOF | LPAREN | RULE | SHORTEST ->
              let _v = _menhir_action_02 () in
              _menhir_goto_boption_ERROR_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_boption_ERROR_ : type  ttv_stack. (((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_40 _1 _startpos__1_ in
      let _menhir_stack = MenhirCell0_positioned_boption_ERROR__ (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_LPAREN (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState039 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | ACTION _ | BAR | EOF | RULE | SHORTEST ->
          let _v = _menhir_action_71 () in
          _menhir_goto_startsymbols _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_startsymbols : type  ttv_stack. (((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE _menhir_cell0_positioned_boption_ERROR__ -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_startsymbols (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | SHORTEST ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState046
      | BAR ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState046
      | ACTION _ | EOF | RULE ->
          let _v_0 = _menhir_action_24 () in
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_045 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_42 _1 _startpos__1_ in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_positioned_ident_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState043 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RPAREN ->
          let x = _v in
          let _v = _menhir_action_65 x in
          _menhir_goto_separated_nonempty_list_COMMA_positioned_ident__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_positioned_ident__ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState039 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState043 ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_040 : type  ttv_stack. (((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_RULE, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_list_ident_ _menhir_cell0_PARSE _menhir_cell0_positioned_boption_ERROR__ _menhir_cell0_LPAREN -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LPAREN (_menhir_stack, _, _) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_72 _2 in
      _menhir_goto_startsymbols _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_044 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_positioned_ident_ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_positioned_ident_ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_66 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_positioned_ident__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_068 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQUAL ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos) in
          let _menhir_s = MenhirState069 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RULE ->
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PARSE ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LBRACKET ->
              let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos, _endpos) in
              let _menhir_s = MenhirState070 in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | UNDERSCORE ->
                  _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | SLASH ->
                  _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | RULE ->
                  _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | PARSE ->
                  _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | LPAREN ->
                  _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | LBRACKET ->
                  _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | IDENT _v ->
                  _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | ERROR ->
                  _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | BAR | RBRACKET ->
                  _menhir_reduce_52 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok
              | _ ->
                  _eRR ())
          | IDENT _v ->
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | ERROR ->
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | ACTION _ | AT | BAR | PARTIAL | QUESTION | RBRACKET | RPAREN | SEMI | SLASH | STAR | UNREACHABLE ->
          let (_startpos__1_, _1) = (_startpos, _v) in
          let _v = _menhir_action_73 _1 in
          _menhir_goto_symbol _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_109 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_ident as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState109
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState109
      | IDENT _v_0 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState109
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState109
      | EQUAL ->
          let _v_1 = _menhir_action_26 () in
          _menhir_run_110 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1
      | _ ->
          _eRR ()
  
  and _menhir_run_110 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_ident, _menhir_box_parse_lexer_definition) _menhir_cell1_ident -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_ident (_menhir_stack, _menhir_s, x, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_27 x xs in
      _menhir_goto_list_ident_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_list_ident_ : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_ident as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_lexer_definition) _menhir_state -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState033 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MenhirState109 ->
          _menhir_run_110 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_nonempty_list_positioned_filter_symbol__ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState012 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState009 ->
          _menhir_run_023 _menhir_stack _v _tok
      | MenhirState000 ->
          _menhir_run_026 _menhir_stack _v _tok
      | MenhirState053 ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState051 ->
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_013 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_positioned_filter_symbol_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_positioned_filter_symbol_ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_34 x xs in
      _menhir_goto_nonempty_list_positioned_filter_symbol__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_054 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_SLASH, _menhir_box_parse_lexer_definition) _menhir_cell1_wild_symbol -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_wild_symbol (_menhir_stack, _, x, _) = _menhir_stack in
      let MenhirCell1_SLASH (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_46 _2 _startpos__1_ x in
      _menhir_goto_regfilter _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_regfilter : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState049 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState056 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState070 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState072 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState061 ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_074 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_state -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let (_startpos__1_, _1) = (_startpos, _v) in
      let _v = _menhir_action_56 _1 in
      _menhir_goto_regseq_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_078 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_regseq_loop -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_regseq_loop (_menhir_stack, _menhir_s, _1, _startpos__1_) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_54 _1 _2 in
      _menhir_goto_regseq_loop _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_055 : type  ttv_stack. (ttv_stack, _menhir_box_parse_lexer_definition) _menhir_cell1_SLASH -> _ -> _ -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_SLASH (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _2 = _v in
      let _v = _menhir_action_45 _2 _startpos__1_ in
      _menhir_goto_regfilter _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_filter =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState000 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RULE ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PARSE ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ERROR ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | DOT ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  let _menhir_run_028 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_lexer_definition =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ACTION _v ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState028
      | RULE ->
          let _v = _menhir_action_17 () in
          _menhir_run_031 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState028 _tok
      | _ ->
          _eRR ()
  
end

let parse_lexer_definition =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_parse_lexer_definition v = _menhir_run_028 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let parse_filter =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_parse_filter v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

# 187 "src/front/parser.mly"
  

# 2706 "src/front/parser.ml"