Source file Parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = Tokens.token
  
end

include MenhirBasics

# 1 "packages/css-spec-parser/lib/Parser.mly"
  

open Ast


# 23 "packages/css-spec-parser/lib/Parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState00 : ('s, _menhir_box_multiplier_of_lex) _menhir_state
    (** State 00.
        Stack shape : .
        Start symbol: multiplier_of_lex. *)

  | MenhirState10 : ('s, _menhir_box_value_of_lex) _menhir_state
    (** State 10.
        Stack shape : .
        Start symbol: value_of_lex. *)

  | MenhirState11 : (('s, _menhir_box_value_of_lex) _menhir_cell1_RIGHT_PARENS, _menhir_box_value_of_lex) _menhir_state
    (** State 11.
        Stack shape : RIGHT_PARENS.
        Start symbol: value_of_lex. *)

  | MenhirState13 : (('s, _menhir_box_value_of_lex) _menhir_cell1_PROPERTY, _menhir_box_value_of_lex) _menhir_state
    (** State 13.
        Stack shape : PROPERTY.
        Start symbol: value_of_lex. *)

  | MenhirState15 : (('s, _menhir_box_value_of_lex) _menhir_cell1_LITERAL, _menhir_box_value_of_lex) _menhir_state
    (** State 15.
        Stack shape : LITERAL.
        Start symbol: value_of_lex. *)

  | MenhirState16 : ((('s, _menhir_box_value_of_lex) _menhir_cell1_LITERAL, _menhir_box_value_of_lex) _menhir_cell1_LEFT_PARENS, _menhir_box_value_of_lex) _menhir_state
    (** State 16.
        Stack shape : LITERAL LEFT_PARENS.
        Start symbol: value_of_lex. *)

  | MenhirState17 : (('s, _menhir_box_value_of_lex) _menhir_cell1_LEFT_PARENS, _menhir_box_value_of_lex) _menhir_state
    (** State 17.
        Stack shape : LEFT_PARENS.
        Start symbol: value_of_lex. *)

  | MenhirState19 : (('s, _menhir_box_value_of_lex) _menhir_cell1_LEFT_BRACKET, _menhir_box_value_of_lex) _menhir_state
    (** State 19.
        Stack shape : LEFT_BRACKET.
        Start symbol: value_of_lex. *)

  | MenhirState20 : (('s, _menhir_box_value_of_lex) _menhir_cell1_DATA, _menhir_box_value_of_lex) _menhir_state
    (** State 20.
        Stack shape : DATA.
        Start symbol: value_of_lex. *)

  | MenhirState22 : (('s, _menhir_box_value_of_lex) _menhir_cell1_CHAR, _menhir_box_value_of_lex) _menhir_state
    (** State 22.
        Stack shape : CHAR.
        Start symbol: value_of_lex. *)

  | MenhirState25 : ((('s, _menhir_box_value_of_lex) _menhir_cell1_LEFT_BRACKET, _menhir_box_value_of_lex) _menhir_cell1_value, _menhir_box_value_of_lex) _menhir_state
    (** State 25.
        Stack shape : LEFT_BRACKET value.
        Start symbol: value_of_lex. *)

  | MenhirState28 : (('s, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list___anonymous_0_group_, _menhir_box_value_of_lex) _menhir_state
    (** State 28.
        Stack shape : separated_nonempty_list(__anonymous_0,group).
        Start symbol: value_of_lex. *)

  | MenhirState30 : (('s, _menhir_box_value_of_lex) _menhir_cell1_group, _menhir_box_value_of_lex) _menhir_state
    (** State 30.
        Stack shape : group.
        Start symbol: value_of_lex. *)

  | MenhirState34 : (('s, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list_DOUBLE_BAR_and_expr_, _menhir_box_value_of_lex) _menhir_state
    (** State 34.
        Stack shape : separated_nonempty_list(DOUBLE_BAR,and_expr).
        Start symbol: value_of_lex. *)

  | MenhirState36 : (('s, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_, _menhir_box_value_of_lex) _menhir_state
    (** State 36.
        Stack shape : separated_nonempty_list(DOUBLE_AMPERSAND,static_expr).
        Start symbol: value_of_lex. *)


and ('s, 'r) _menhir_cell1_group = 
  | MenhirCell1_group of 's * ('s, 'r) _menhir_state * (Ast.value)

and ('s, 'r) _menhir_cell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ = 
  | MenhirCell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ of 's * ('s, 'r) _menhir_state * (Ast.value list)

and ('s, 'r) _menhir_cell1_separated_nonempty_list_DOUBLE_BAR_and_expr_ = 
  | MenhirCell1_separated_nonempty_list_DOUBLE_BAR_and_expr_ of 's * ('s, 'r) _menhir_state * (Ast.value list)

and ('s, 'r) _menhir_cell1_separated_nonempty_list___anonymous_0_group_ = 
  | MenhirCell1_separated_nonempty_list___anonymous_0_group_ of 's * ('s, 'r) _menhir_state * (Ast.value list)

and ('s, 'r) _menhir_cell1_value = 
  | MenhirCell1_value of 's * ('s, 'r) _menhir_state * (Ast.value)

and ('s, 'r) _menhir_cell1_CHAR = 
  | MenhirCell1_CHAR of 's * ('s, 'r) _menhir_state * (
# 8 "packages/css-spec-parser/lib/Parser.mly"
       (string)
# 121 "packages/css-spec-parser/lib/Parser.ml"
)

and ('s, 'r) _menhir_cell1_DATA = 
  | MenhirCell1_DATA of 's * ('s, 'r) _menhir_state * (
# 9 "packages/css-spec-parser/lib/Parser.mly"
       (string)
# 128 "packages/css-spec-parser/lib/Parser.ml"
)

and ('s, 'r) _menhir_cell1_LEFT_BRACKET = 
  | MenhirCell1_LEFT_BRACKET of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LEFT_PARENS = 
  | MenhirCell1_LEFT_PARENS of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LITERAL = 
  | MenhirCell1_LITERAL of 's * ('s, 'r) _menhir_state * (
# 7 "packages/css-spec-parser/lib/Parser.mly"
       (string)
# 141 "packages/css-spec-parser/lib/Parser.ml"
)

and ('s, 'r) _menhir_cell1_PROPERTY = 
  | MenhirCell1_PROPERTY of 's * ('s, 'r) _menhir_state * (
# 10 "packages/css-spec-parser/lib/Parser.mly"
       (string)
# 148 "packages/css-spec-parser/lib/Parser.ml"
)

and ('s, 'r) _menhir_cell1_RIGHT_PARENS = 
  | MenhirCell1_RIGHT_PARENS of 's * ('s, 'r) _menhir_state

and _menhir_box_value_of_lex = 
  | MenhirBox_value_of_lex of (Ast.value option) [@@unboxed]

and _menhir_box_multiplier_of_lex = 
  | MenhirBox_multiplier_of_lex of (Ast.multiplier option) [@@unboxed]

let _menhir_action_02 =
  fun c ->
    let t = 
# 54 "packages/css-spec-parser/lib/Parser.mly"
              ( Delim c )
# 165 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 170 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_03 =
  fun l ->
    let t = 
# 55 "packages/css-spec-parser/lib/Parser.mly"
                 ( Keyword l )
# 178 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 183 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_04 =
  fun d ->
    let t = 
# 56 "packages/css-spec-parser/lib/Parser.mly"
              ( Data_type d )
# 191 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 196 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_05 =
  fun p ->
    let t = 
# 57 "packages/css-spec-parser/lib/Parser.mly"
                  ( Property_type p )
# 204 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 209 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_06 =
  fun c m ->
    let t = 
# 54 "packages/css-spec-parser/lib/Parser.mly"
              ( Delim c )
# 217 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 222 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_07 =
  fun l m ->
    let t = 
# 55 "packages/css-spec-parser/lib/Parser.mly"
                 ( Keyword l )
# 230 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 235 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_08 =
  fun d m ->
    let t = 
# 56 "packages/css-spec-parser/lib/Parser.mly"
              ( Data_type d )
# 243 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 248 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_09 =
  fun m p ->
    let t = 
# 57 "packages/css-spec-parser/lib/Parser.mly"
                  ( Property_type p )
# 256 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 261 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_10 =
  fun _2 _4 l v ->
    (
# 65 "packages/css-spec-parser/lib/Parser.mly"
                                                       ( Function_call(l, v) )
# 269 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_11 =
  fun _1 ->
    (_1 : (Ast.value))

let _menhir_action_12 =
  fun _1 _3 v ->
    (
# 69 "packages/css-spec-parser/lib/Parser.mly"
                                            ( v )
# 281 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_13 =
  fun _1 _3 m v ->
    (
# 70 "packages/css-spec-parser/lib/Parser.mly"
                                                            ( Group(v, m) )
# 289 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_14 =
  fun _1 ->
    (
# 39 "packages/css-spec-parser/lib/Parser.mly"
    ( Zero_or_more )
# 297 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier))

let _menhir_action_15 =
  fun _1 ->
    (
# 41 "packages/css-spec-parser/lib/Parser.mly"
    ( One_or_more )
# 305 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier))

let _menhir_action_16 =
  fun _1 ->
    (
# 43 "packages/css-spec-parser/lib/Parser.mly"
    ( Optional )
# 313 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier))

let _menhir_action_17 =
  fun r ->
    (
# 45 "packages/css-spec-parser/lib/Parser.mly"
    (
      match r with
      | (`Space, min, max) -> Repeat (min, max)
      | (`Comma, min, max) -> Repeat_by_comma (min, max)
    )
# 325 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier))

let _menhir_action_18 =
  fun _1 ->
    (
# 51 "packages/css-spec-parser/lib/Parser.mly"
    ( At_least_one )
# 333 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier))

let _menhir_action_19 =
  fun _1 ->
    (
# 34 "packages/css-spec-parser/lib/Parser.mly"
         ( None )
# 341 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier option))

let _menhir_action_20 =
  fun _2 m ->
    (
# 35 "packages/css-spec-parser/lib/Parser.mly"
                         ( Some m )
# 349 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.multiplier option))

let _menhir_action_21 =
  fun vs ->
    let x =
      let kind = 
# 81 "packages/css-spec-parser/lib/Parser.mly"
                                       ( Or )
# 358 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 363 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 369 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_22 =
  fun vs xs ->
    let x =
      let kind = 
# 81 "packages/css-spec-parser/lib/Parser.mly"
                                       ( Or )
# 378 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 383 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 389 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_23 =
  fun vs ->
    let x =
      let kind = 
# 77 "packages/css-spec-parser/lib/Parser.mly"
                              ( Static )
# 398 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 403 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 409 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_24 =
  fun vs xs ->
    let x =
      let kind = 
# 77 "packages/css-spec-parser/lib/Parser.mly"
                              ( Static )
# 418 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 423 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 429 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_25 =
  fun vs ->
    let x =
      let kind = 
# 79 "packages/css-spec-parser/lib/Parser.mly"
                                                ( And )
# 438 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 443 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 449 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_26 =
  fun vs xs ->
    let x =
      let kind = 
# 79 "packages/css-spec-parser/lib/Parser.mly"
                                                ( And )
# 458 "packages/css-spec-parser/lib/Parser.ml"
       in
      
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 463 "packages/css-spec-parser/lib/Parser.ml"
      
    in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 469 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_27 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 477 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_28 =
  fun x xs ->
    let _2 = 
# 77 "packages/css-spec-parser/lib/Parser.mly"
                 ()
# 485 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 490 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value list))

let _menhir_action_29 =
  fun vs ->
    let kind = 
# 83 "packages/css-spec-parser/lib/Parser.mly"
                               ( Xor )
# 498 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 74 "packages/css-spec-parser/lib/Parser.mly"
    ( match vs with | v::[] -> v | vs -> Combinator(kind, vs) )
# 503 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_30 =
  fun _1 ->
    let t = 
# 88 "packages/css-spec-parser/lib/Parser.mly"
                                        ( Keyword ")" )
# 511 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 516 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_31 =
  fun _1 ->
    let t = 
# 88 "packages/css-spec-parser/lib/Parser.mly"
                                                                       ( Keyword "(" )
# 524 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 60 "packages/css-spec-parser/lib/Parser.mly"
                  ( Terminal(t, One) )
# 529 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_32 =
  fun _1 m ->
    let t = 
# 88 "packages/css-spec-parser/lib/Parser.mly"
                                        ( Keyword ")" )
# 537 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 542 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_33 =
  fun _1 m ->
    let t = 
# 88 "packages/css-spec-parser/lib/Parser.mly"
                                                                       ( Keyword "(" )
# 550 "packages/css-spec-parser/lib/Parser.ml"
     in
    (
# 61 "packages/css-spec-parser/lib/Parser.mly"
                                  ( Terminal(t, m) )
# 555 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value))

let _menhir_action_34 =
  fun _1 ->
    (
# 30 "packages/css-spec-parser/lib/Parser.mly"
         ( None )
# 563 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value option))

let _menhir_action_35 =
  fun _2 v ->
    (
# 31 "packages/css-spec-parser/lib/Parser.mly"
                    ( Some v )
# 571 "packages/css-spec-parser/lib/Parser.ml"
     : (Ast.value option))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | Tokens.ASTERISK ->
        "ASTERISK"
    | Tokens.BAR ->
        "BAR"
    | Tokens.CHAR _ ->
        "CHAR"
    | Tokens.DATA _ ->
        "DATA"
    | Tokens.DOUBLE_AMPERSAND ->
        "DOUBLE_AMPERSAND"
    | Tokens.DOUBLE_BAR ->
        "DOUBLE_BAR"
    | Tokens.EOF ->
        "EOF"
    | Tokens.EXCLAMATION_POINT ->
        "EXCLAMATION_POINT"
    | Tokens.LEFT_BRACKET ->
        "LEFT_BRACKET"
    | Tokens.LEFT_PARENS ->
        "LEFT_PARENS"
    | Tokens.LITERAL _ ->
        "LITERAL"
    | Tokens.PLUS ->
        "PLUS"
    | Tokens.PROPERTY _ ->
        "PROPERTY"
    | Tokens.QUESTION_MARK ->
        "QUESTION_MARK"
    | Tokens.RANGE _ ->
        "RANGE"
    | Tokens.RIGHT_BRACKET ->
        "RIGHT_BRACKET"
    | Tokens.RIGHT_PARENS ->
        "RIGHT_PARENS"

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_goto_value_of_lex : type  ttv_stack. ttv_stack -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _v ->
      MenhirBox_value_of_lex _v
  
  let _menhir_run_45 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.EOF ->
          let (v, _2) = (_v, ()) in
          let _v = _menhir_action_35 _2 v in
          _menhir_goto_value_of_lex _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_goto_multiplier_of_lex : type  ttv_stack. ttv_stack -> _ -> _menhir_box_multiplier_of_lex =
    fun _menhir_stack _v ->
      MenhirBox_multiplier_of_lex _v
  
  let _menhir_run_08 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_multiplier_of_lex =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.EOF ->
          let (m, _2) = (_v, ()) in
          let _v = _menhir_action_20 _2 m in
          _menhir_goto_multiplier_of_lex _menhir_stack _v
      | _ ->
          _eRR ()
  
  let rec _menhir_run_01 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let r = _v in
      let _v = _menhir_action_17 r in
      _menhir_goto_multiplier _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_multiplier : 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
      | MenhirState15 ->
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState25 ->
          _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState22 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState20 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState17 ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState13 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState11 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState00 ->
          _menhir_run_08 _menhir_stack _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_42 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_LITERAL -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_LITERAL (_menhir_stack, _menhir_s, l) = _menhir_stack in
      let m = _v in
      let _v = _menhir_action_07 l m in
      _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_function_call : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _1 = _v in
      let _v = _menhir_action_11 _1 in
      _menhir_goto_group _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_group : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.PROPERTY _v_0 ->
          let _menhir_stack = MenhirCell1_group (_menhir_stack, _menhir_s, _v) in
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState30
      | Tokens.LITERAL _v_1 ->
          let _menhir_stack = MenhirCell1_group (_menhir_stack, _menhir_s, _v) in
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState30
      | Tokens.LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_group (_menhir_stack, _menhir_s, _v) in
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | Tokens.DATA _v_2 ->
          let _menhir_stack = MenhirCell1_group (_menhir_stack, _menhir_s, _v) in
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState30
      | Tokens.CHAR _v_3 ->
          let _menhir_stack = MenhirCell1_group (_menhir_stack, _menhir_s, _v) in
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState30
      | Tokens.BAR | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let x = _v in
          let _v = _menhir_action_27 x in
          _menhir_goto_separated_nonempty_list___anonymous_0_group_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_13 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v_0 ->
          let _menhir_stack = MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, _v) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState13
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, _v) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState13
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, _v) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState13
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, _v) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState13
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, _v) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState13
      | Tokens.BAR | Tokens.CHAR _ | Tokens.DATA _ | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.LEFT_BRACKET | Tokens.LITERAL _ | Tokens.PROPERTY _ | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let p = _v in
          let _v = _menhir_action_05 p in
          _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_02 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = () in
      let _v = _menhir_action_16 _1 in
      _menhir_goto_multiplier _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_03 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = () in
      let _v = _menhir_action_15 _1 in
      _menhir_goto_multiplier _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_04 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = () in
      let _v = _menhir_action_18 _1 in
      _menhir_goto_multiplier _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_06 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let _1 = () in
      let _v = _menhir_action_14 _1 in
      _menhir_goto_multiplier _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_15 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v_0 ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState15
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState15
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState15
      | Tokens.LEFT_PARENS ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, MenhirState15) in
          let _menhir_s = MenhirState16 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Tokens.RIGHT_PARENS ->
              _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.PROPERTY _v ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LITERAL _v ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LEFT_PARENS ->
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.LEFT_BRACKET ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.DATA _v ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.CHAR _v ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState15
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_LITERAL (_menhir_stack, _menhir_s, _v) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState15
      | Tokens.BAR | Tokens.CHAR _ | Tokens.DATA _ | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.LEFT_BRACKET | Tokens.LITERAL _ | Tokens.PROPERTY _ | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let l = _v in
          let _v = _menhir_action_03 l in
          _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_11 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v ->
          let _menhir_stack = MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState11
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState11
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState11
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState11
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState11
      | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let _1 = () in
          let _v = _menhir_action_30 _1 in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_value : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState10 ->
          _menhir_run_45 _menhir_stack _v _tok
      | MenhirState16 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState19 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_40 : type  ttv_stack. ((ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_LITERAL, _menhir_box_value_of_lex) _menhir_cell1_LEFT_PARENS -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.RIGHT_PARENS ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LEFT_PARENS (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_LITERAL (_menhir_stack, _menhir_s, l) = _menhir_stack in
          let (v, _2, _4) = (_v, (), ()) in
          let _v = _menhir_action_10 _2 _4 l v in
          _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_24 : type  ttv_stack. ((ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_LEFT_BRACKET as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.RIGHT_BRACKET ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Tokens.RANGE _v_0 ->
              let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v) in
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState25
          | Tokens.QUESTION_MARK ->
              let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v) in
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState25
          | Tokens.PLUS ->
              let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v) in
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState25
          | Tokens.EXCLAMATION_POINT ->
              let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v) in
              _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState25
          | Tokens.ASTERISK ->
              let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v) in
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState25
          | Tokens.BAR | Tokens.CHAR _ | Tokens.DATA _ | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.LEFT_BRACKET | Tokens.LITERAL _ | Tokens.PROPERTY _ | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
              let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s) = _menhir_stack in
              let (_1, _3, v) = ((), (), _v) in
              let _v = _menhir_action_12 _1 _3 v in
              _menhir_goto_group _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_17 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v ->
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let _1 = () in
          let _v = _menhir_action_31 _1 in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_19 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState19 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RIGHT_PARENS ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | Tokens.PROPERTY _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Tokens.LITERAL _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Tokens.LEFT_PARENS ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | Tokens.LEFT_BRACKET ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | Tokens.DATA _v ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | Tokens.CHAR _v ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_20 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v_0 ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState20
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_DATA (_menhir_stack, _menhir_s, _v) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | Tokens.BAR | Tokens.CHAR _ | Tokens.DATA _ | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.LEFT_BRACKET | Tokens.LITERAL _ | Tokens.PROPERTY _ | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let d = _v in
          let _v = _menhir_action_04 d in
          _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_22 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v_0 ->
          let _menhir_stack = MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState22
      | Tokens.QUESTION_MARK ->
          let _menhir_stack = MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState22
      | Tokens.PLUS ->
          let _menhir_stack = MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState22
      | Tokens.EXCLAMATION_POINT ->
          let _menhir_stack = MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState22
      | Tokens.ASTERISK ->
          let _menhir_stack = MenhirCell1_CHAR (_menhir_stack, _menhir_s, _v) in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState22
      | Tokens.BAR | Tokens.CHAR _ | Tokens.DATA _ | Tokens.DOUBLE_AMPERSAND | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.LEFT_BRACKET | Tokens.LITERAL _ | Tokens.PROPERTY _ | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let c = _v in
          let _v = _menhir_action_02 c in
          _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list___anonymous_0_group_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState30 ->
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState10 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState16 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState36 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState34 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState28 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_31 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_group -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_group (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_28 x xs in
      _menhir_goto_separated_nonempty_list___anonymous_0_group_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_27 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.DOUBLE_AMPERSAND ->
          let _menhir_stack = MenhirCell1_separated_nonempty_list___anonymous_0_group_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState28 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Tokens.PROPERTY _v ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LITERAL _v ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LEFT_BRACKET ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.DATA _v ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.CHAR _v ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | Tokens.BAR | Tokens.DOUBLE_BAR | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let vs = _v in
          let _v = _menhir_action_23 vs in
          _menhir_goto_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState10 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState16 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState36 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState34 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState28 ->
          _menhir_run_29 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_35 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.DOUBLE_BAR ->
          let _menhir_stack = MenhirCell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState36 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Tokens.PROPERTY _v ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LITERAL _v ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LEFT_BRACKET ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.DATA _v ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.CHAR _v ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | Tokens.BAR | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let vs = _v in
          let _v = _menhir_action_25 vs in
          _menhir_goto_separated_nonempty_list_DOUBLE_BAR_and_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_separated_nonempty_list_DOUBLE_BAR_and_expr_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState36 ->
          _menhir_run_37 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState10 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState16 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState34 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_37 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ (_menhir_stack, _menhir_s, vs) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_26 vs xs in
      _menhir_goto_separated_nonempty_list_DOUBLE_BAR_and_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_33 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | Tokens.BAR ->
          let _menhir_stack = MenhirCell1_separated_nonempty_list_DOUBLE_BAR_and_expr_ (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState34 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | Tokens.PROPERTY _v ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LITERAL _v ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.LEFT_BRACKET ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | Tokens.DATA _v ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | Tokens.CHAR _v ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | Tokens.EOF | Tokens.RIGHT_BRACKET | Tokens.RIGHT_PARENS ->
          let vs = _v in
          let _v = _menhir_action_21 vs in
          _menhir_goto_separated_nonempty_list_BAR_or_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_goto_separated_nonempty_list_BAR_or_expr_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState10 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState16 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState34 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_39 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_value_of_lex) _menhir_state -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let vs = _v in
      let _v = _menhir_action_29 vs in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_38 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list_DOUBLE_BAR_and_expr_ -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_separated_nonempty_list_DOUBLE_BAR_and_expr_ (_menhir_stack, _menhir_s, vs) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_22 vs xs in
      _menhir_goto_separated_nonempty_list_BAR_or_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_29 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_separated_nonempty_list___anonymous_0_group_ -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_separated_nonempty_list___anonymous_0_group_ (_menhir_stack, _menhir_s, vs) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_24 vs xs in
      _menhir_goto_separated_nonempty_list_DOUBLE_AMPERSAND_static_expr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_26 : type  ttv_stack. ((ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_LEFT_BRACKET, _menhir_box_value_of_lex) _menhir_cell1_value -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_value (_menhir_stack, _, v) = _menhir_stack in
      let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s) = _menhir_stack in
      let (_1, m, _3) = ((), _v, ()) in
      let _v = _menhir_action_13 _1 _3 m v in
      _menhir_goto_group _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_23 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_CHAR -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_CHAR (_menhir_stack, _menhir_s, c) = _menhir_stack in
      let m = _v in
      let _v = _menhir_action_06 c m in
      _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_21 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_DATA -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_DATA (_menhir_stack, _menhir_s, d) = _menhir_stack in
      let m = _v in
      let _v = _menhir_action_08 d m in
      _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_18 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_LEFT_PARENS -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_LEFT_PARENS (_menhir_stack, _menhir_s) = _menhir_stack in
      let (_1, m) = ((), _v) in
      let _v = _menhir_action_33 _1 m in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_14 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_PROPERTY -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_PROPERTY (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let m = _v in
      let _v = _menhir_action_09 m p in
      _menhir_goto_function_call _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_12 : type  ttv_stack. (ttv_stack, _menhir_box_value_of_lex) _menhir_cell1_RIGHT_PARENS -> _ -> _ -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_RIGHT_PARENS (_menhir_stack, _menhir_s) = _menhir_stack in
      let (_1, m) = ((), _v) in
      let _v = _menhir_action_32 _1 m in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_multiplier_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RANGE _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState00
      | Tokens.QUESTION_MARK ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState00
      | Tokens.PLUS ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState00
      | Tokens.EXCLAMATION_POINT ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState00
      | Tokens.EOF ->
          let _1 = () in
          let _v = _menhir_action_19 _1 in
          _menhir_goto_multiplier_of_lex _menhir_stack _v
      | Tokens.ASTERISK ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState00
      | _ ->
          _eRR ()
  
  let _menhir_run_10 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_value_of_lex =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | Tokens.RIGHT_PARENS ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState10
      | Tokens.PROPERTY _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState10
      | Tokens.LITERAL _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState10
      | Tokens.LEFT_PARENS ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState10
      | Tokens.LEFT_BRACKET ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState10
      | Tokens.EOF ->
          let _1 = () in
          let _v = _menhir_action_34 _1 in
          _menhir_goto_value_of_lex _menhir_stack _v
      | Tokens.DATA _v ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState10
      | Tokens.CHAR _v ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState10
      | _ ->
          _eRR ()
  
end

let value_of_lex =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_value_of_lex v = _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let multiplier_of_lex =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_multiplier_of_lex v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v