Source file mik_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | UNDERSCORE
    | TILDE
    | STRING_LITERAL of 
# 69 "lib/mik_parser.mly"
       (string)
# 17 "lib/mik_parser.ml"
  
    | STAR
    | SLASH
    | RPAREN
    | RBRACKET
    | RBRACE
    | QUESTION
    | PREDEFINED_CLASS of 
# 69 "lib/mik_parser.mly"
       (string)
# 28 "lib/mik_parser.ml"
  
    | PLUS
    | PIPE
    | MOD_IDENT of 
# 69 "lib/mik_parser.mly"
       (string)
# 35 "lib/mik_parser.ml"
  
    | LPAREN
    | LBRACKET
    | LBRACE
    | INT_CONVERTER
    | INT of 
# 69 "lib/mik_parser.mly"
       (string)
# 44 "lib/mik_parser.ml"
  
    | IDENT of 
# 69 "lib/mik_parser.mly"
       (string)
# 49 "lib/mik_parser.ml"
  
    | FLOAT_CONVERTER
    | EQUAL
    | EOF
    | EMPTY_STR
    | DASH
    | COLON
    | CHAR_LITERAL of 
# 69 "lib/mik_parser.mly"
       (string)
# 60 "lib/mik_parser.ml"
  
    | CARET
    | BAR
    | AS
  
end

include MenhirBasics

# 1 "lib/mik_parser.mly"
  
open Regexp_types

let nonepsilon = function { Location.txt = Seq []; _ } -> false | _ -> true

let mkloc = Location.mkloc

let simplify_seq ~loc es =
  match List.filter nonepsilon es with
  | [ e ] -> e
  | es -> mkloc (Seq es) loc

let simplify_alt es =
  match es with
  | [ e ] -> e.Location.txt
  | es -> Alt es

let make_loc startpos endpos =
  Location.{
    loc_start = startpos;
    loc_end = endpos;
    loc_ghost = false;
  }

let wrap_loc startpos endpos x =
  Location.{
    txt = x;
    loc = make_loc startpos endpos;
  }

let to_pcre_regex str startpos endpos =
  wrap_loc startpos endpos (Code str)

let syntax_error msg startpos endpos =
  let loc = make_loc startpos endpos in
  raise @@ PError (loc, msg)

let missing_error what startpos endpos =
  syntax_error (Printf.sprintf "Missing %s" what) startpos endpos

let unclosed_error what startpos endpos =
  syntax_error (Printf.sprintf "Unclosed %s" what) startpos endpos

let string_to_longident s =
  let open Ppxlib_ast.Ast in
  match String.split_on_char '.' s with
  | [] -> invalid_arg "string_to_longident: empty string"
  | [ x ] -> Lident x
  | x :: xs -> List.fold_left (fun acc s -> Ldot (acc, s)) (Lident x) xs

let last_component s =
  match List.rev (String.split_on_char '.' s) with
  | [] -> s
  | hd :: _ -> hd

let parse_flags s startpos endpos =
  let rec loop i flags =
    if i >= String.length s then flags
    else
      match s.[i] with
      | ' ' | '\t' | '\n' | '\r' -> loop (i + 1) flags
      | 'i' -> loop (i + 1) { flags with case_insensitive = true }
      | 'u' -> loop (i + 1) { flags with anchored = false }
      | c -> syntax_error (Printf.sprintf "Unknown flag '%c'" c) startpos endpos
  in
  loop 0 mikmatch_default_flags

# 138 "lib/mik_parser.ml"

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

  | MenhirState008 : (('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_state
    (** State 008.
        Stack shape : LPAREN.
        Start symbol: <undetermined>. *)

  | MenhirState013 : ((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON, 'r) _menhir_state
    (** State 013.
        Stack shape : LPAREN MOD_IDENT COLON.
        Start symbol: <undetermined>. *)

  | MenhirState020 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_state
    (** State 020.
        Stack shape : LPAREN MOD_IDENT COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState023 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 023.
        Stack shape : LPAREN MOD_IDENT COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState033 : ((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 033.
        Stack shape : LPAREN MOD_IDENT AS IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState036 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_state
    (** State 036.
        Stack shape : LPAREN MOD_IDENT AS IDENT COLON.
        Start symbol: <undetermined>. *)

  | MenhirState038 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_INT_CONVERTER, 'r) _menhir_state
    (** State 038.
        Stack shape : LPAREN MOD_IDENT AS IDENT COLON INT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState041 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_FLOAT_CONVERTER, 'r) _menhir_state
    (** State 041.
        Stack shape : LPAREN MOD_IDENT AS IDENT COLON FLOAT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState044 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_state
    (** State 044.
        Stack shape : LPAREN MOD_IDENT AS IDENT COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState047 : (((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 047.
        Stack shape : LPAREN MOD_IDENT AS IDENT COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState053 : (('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_state
    (** State 053.
        Stack shape : LBRACKET.
        Start symbol: <undetermined>. *)

  | MenhirState065 : ((('s, 'r) _menhir_cell1_LBRACKET, 'r) _menhir_cell1_CARET, 'r) _menhir_state
    (** State 065.
        Stack shape : LBRACKET CARET.
        Start symbol: <undetermined>. *)

  | MenhirState067 : (('s, 'r) _menhir_cell1_char_set_item, 'r) _menhir_state
    (** State 067.
        Stack shape : char_set_item.
        Start symbol: <undetermined>. *)

  | MenhirState075 : ((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_COLON, 'r) _menhir_state
    (** State 075.
        Stack shape : LPAREN IDENT COLON.
        Start symbol: <undetermined>. *)

  | MenhirState080 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_state
    (** State 080.
        Stack shape : LPAREN IDENT COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState083 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 083.
        Stack shape : LPAREN IDENT COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState093 : ((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 093.
        Stack shape : LPAREN IDENT AS IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState095 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_state
    (** State 095.
        Stack shape : LPAREN IDENT AS IDENT COLON.
        Start symbol: <undetermined>. *)

  | MenhirState097 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_INT_CONVERTER, 'r) _menhir_state
    (** State 097.
        Stack shape : LPAREN IDENT AS IDENT COLON INT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState100 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_FLOAT_CONVERTER, 'r) _menhir_state
    (** State 100.
        Stack shape : LPAREN IDENT AS IDENT COLON FLOAT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState103 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_state
    (** State 103.
        Stack shape : LPAREN IDENT AS IDENT COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState106 : (((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 106.
        Stack shape : LPAREN IDENT AS IDENT COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState117 : (('s, 'r) _menhir_cell1_seq_expr _menhir_cell0_BAR, 'r) _menhir_state
    (** State 117.
        Stack shape : seq_expr BAR.
        Start symbol: <undetermined>. *)

  | MenhirState134 : (('s, 'r) _menhir_cell1_atom_expr, 'r) _menhir_state
    (** State 134.
        Stack shape : atom_expr.
        Start symbol: <undetermined>. *)

  | MenhirState137 : ((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_state
    (** State 137.
        Stack shape : LPAREN pattern.
        Start symbol: <undetermined>. *)

  | MenhirState141 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 141.
        Stack shape : LPAREN pattern AS IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState143 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_state
    (** State 143.
        Stack shape : LPAREN pattern AS IDENT COLON.
        Start symbol: <undetermined>. *)

  | MenhirState145 : (((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_INT_CONVERTER, 'r) _menhir_state
    (** State 145.
        Stack shape : LPAREN pattern AS IDENT COLON INT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState148 : (((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_FLOAT_CONVERTER, 'r) _menhir_state
    (** State 148.
        Stack shape : LPAREN pattern AS IDENT COLON FLOAT_CONVERTER.
        Start symbol: <undetermined>. *)

  | MenhirState151 : (((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_state
    (** State 151.
        Stack shape : LPAREN pattern AS IDENT COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState155 : ((((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_IDENT, 'r) _menhir_cell1_COLON, 'r) _menhir_cell1_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 155.
        Stack shape : LPAREN pattern AS IDENT COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState166 : (((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_COLON _menhir_cell0_EQUAL, 'r) _menhir_state
    (** State 166.
        Stack shape : LPAREN pattern AS COLON EQUAL.
        Start symbol: <undetermined>. *)

  | MenhirState169 : ((((('s, 'r) _menhir_cell1_LPAREN, 'r) _menhir_cell1_pattern, 'r) _menhir_cell1_AS _menhir_cell0_COLON _menhir_cell0_EQUAL, 'r) _menhir_cell1_ident _menhir_cell0_COLON, 'r) _menhir_state
    (** State 169.
        Stack shape : LPAREN pattern AS COLON EQUAL ident COLON.
        Start symbol: <undetermined>. *)

  | MenhirState174 : (('s, 'r) _menhir_cell1_alt_expr _menhir_cell0_PIPE, 'r) _menhir_state
    (** State 174.
        Stack shape : alt_expr PIPE.
        Start symbol: <undetermined>. *)

  | MenhirState181 : ('s, _menhir_box_main_match_case) _menhir_state
    (** State 181.
        Stack shape : <empty>.
        Start symbol: main_match_case. *)

  | MenhirState183 : (('s, _menhir_box_main_match_case) _menhir_cell1_SLASH, _menhir_box_main_match_case) _menhir_state
    (** State 183.
        Stack shape : SLASH.
        Start symbol: main_match_case. *)

  | MenhirState194 : ('s, _menhir_box_pattern) _menhir_state
    (** State 194.
        Stack shape : <empty>.
        Start symbol: pattern. *)


and ('s, 'r) _menhir_cell1_alt_expr = 
  | MenhirCell1_alt_expr of 's * ('s, 'r) _menhir_state * (string Regexp_types.t) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_atom_expr = 
  | MenhirCell1_atom_expr of 's * ('s, 'r) _menhir_state * (string Regexp_types.t) * Lexing.position * Lexing.position

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

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

and ('s, 'r) _menhir_cell1_pattern = 
  | MenhirCell1_pattern of 's * ('s, 'r) _menhir_state * (string Regexp_types.t) * Lexing.position

and ('s, 'r) _menhir_cell1_seq_expr = 
  | MenhirCell1_seq_expr of 's * ('s, 'r) _menhir_state * (string Regexp_types.t) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_AS = 
  | MenhirCell1_AS of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position

and 's _menhir_cell0_AS = 
  | MenhirCell0_AS of 's * Lexing.position * Lexing.position

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

and ('s, 'r) _menhir_cell1_CARET = 
  | MenhirCell1_CARET of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position

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

and 's _menhir_cell0_COLON = 
  | MenhirCell0_COLON of 's * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_EQUAL = 
  | MenhirCell1_EQUAL of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_EQUAL = 
  | MenhirCell0_EQUAL of 's * Lexing.position

and ('s, 'r) _menhir_cell1_FLOAT_CONVERTER = 
  | MenhirCell1_FLOAT_CONVERTER of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_IDENT = 
  | MenhirCell1_IDENT of 's * ('s, 'r) _menhir_state * 
# 69 "lib/mik_parser.mly"
       (string)
# 381 "lib/mik_parser.ml"
 * Lexing.position * Lexing.position

and 's _menhir_cell0_IDENT = 
  | MenhirCell0_IDENT of 's * 
# 69 "lib/mik_parser.mly"
       (string)
# 388 "lib/mik_parser.ml"
 * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_INT_CONVERTER = 
  | MenhirCell1_INT_CONVERTER of 's * ('s, 'r) _menhir_state * Lexing.position

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

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

and ('s, 'r) _menhir_cell1_MOD_IDENT = 
  | MenhirCell1_MOD_IDENT of 's * ('s, 'r) _menhir_state * 
# 69 "lib/mik_parser.mly"
       (string)
# 404 "lib/mik_parser.ml"
 * Lexing.position * Lexing.position

and 's _menhir_cell0_PIPE = 
  | MenhirCell0_PIPE of 's * Lexing.position * Lexing.position

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

and _menhir_box_pattern = 
  | MenhirBox_pattern of (string Regexp_types.t) [@@unboxed]

and _menhir_box_main_match_case = 
  | MenhirBox_main_match_case of (string Regexp_types.t * Regexp_types.flags) [@@unboxed]

and _menhir_box_main_let_expr = 
  | MenhirBox_main_let_expr of (string Regexp_types.t * Regexp_types.flags) [@@unboxed]

let _menhir_action_003 =
  fun _1 ->
    (
# 116 "lib/mik_parser.mly"
             ( _1 )
# 427 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_004 =
  fun _1 _3 _endpos__3_ _startpos__1_ ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos__1_ in
    (
# 117 "lib/mik_parser.mly"
                          (
      let loc = make_loc _startpos _endpos in
      mkloc (simplify_alt [_1; _3]) loc
    )
# 440 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_005 =
  fun _endpos__2_ _startpos__2_ ->
    let _endpos = _endpos__2_ in
    (
# 121 "lib/mik_parser.mly"
                 ( missing_error "expression after '|'" _startpos__2_ _endpos )
# 449 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_006 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 122 "lib/mik_parser.mly"
        ( missing_error "expression before '|'" _startpos _endpos )
# 459 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_007 =
  fun _1 ->
    (
# 132 "lib/mik_parser.mly"
               ( _1 )
# 467 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_008 =
  fun _1 _endpos__2_ _startpos__1_ _startpos__2_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 133 "lib/mik_parser.mly"
                    (
      let repeat_loc = wrap_loc _startpos__2_ _endpos__2_ (0, None) in
      wrap_loc _startpos _endpos (Repeat (repeat_loc, _1))
    )
# 480 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_009 =
  fun _1 _endpos__2_ _startpos__1_ _startpos__2_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 137 "lib/mik_parser.mly"
                    (
      let repeat_loc = wrap_loc _startpos__2_ _endpos__2_ (1, None) in
      wrap_loc _startpos _endpos (Repeat (repeat_loc, _1))
    )
# 493 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_010 =
  fun _1 _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 141 "lib/mik_parser.mly"
                        (
      wrap_loc _startpos _endpos (Opt _1)
    )
# 505 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_011 =
  fun _1 _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 144 "lib/mik_parser.mly"
                     (
      wrap_loc _startpos _endpos (Caseless _1)
    )
# 517 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_012 =
  fun _1 _endpos__4_ _startpos__1_ _startpos__2_ n ->
    let _endpos = _endpos__4_ in
    let _startpos = _startpos__1_ in
    (
# 147 "lib/mik_parser.mly"
                                     (
      let n = int_of_string n in
      let repeat_loc = wrap_loc _startpos__2_ _endpos__4_ (n, Some n) in
      wrap_loc _startpos _endpos (Repeat (repeat_loc, _1))
    )
# 531 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_013 =
  fun _1 _endpos__6_ _startpos__1_ _startpos__2_ max min ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos__1_ in
    (
# 152 "lib/mik_parser.mly"
                                                      (
      let repeat_loc = wrap_loc _startpos__2_ _endpos__6_ (int_of_string min, Some (int_of_string max)) in
      wrap_loc _startpos _endpos (Repeat (repeat_loc, _1))
    )
# 544 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_014 =
  fun _1 _endpos__5_ _startpos__1_ _startpos__2_ min ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 156 "lib/mik_parser.mly"
                                            (
      let repeat_loc = wrap_loc _startpos__2_ _endpos__5_ (int_of_string min, None) in
      wrap_loc _startpos _endpos (Repeat (repeat_loc, _1))
    )
# 557 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_015 =
  fun _endpos__3_ _startpos__2_ ->
    (
# 161 "lib/mik_parser.mly"
                             ( missing_error "repetition count" _startpos__2_ _endpos__3_ )
# 565 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_016 =
  fun _endpos__5_ _startpos__4_ ->
    (
# 162 "lib/mik_parser.mly"
                                    ( syntax_error "Invalid repetition range" _startpos__4_ _endpos__5_ )
# 573 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_017 =
  fun _endpos__3_ _startpos__2_ ->
    let _endpos = _endpos__3_ in
    (
# 163 "lib/mik_parser.mly"
                          ( unclosed_error "repetition (missing '}')" _startpos__2_ _endpos )
# 582 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_018 =
  fun _endpos__3_ _startpos__2_ ->
    let _ = let _endpos = _endpos__3_ in
    (
# 164 "lib/mik_parser.mly"
                            ( syntax_error "Invalid repetition syntax" _startpos__2_ _endpos )
# 591 "lib/mik_parser.ml"
     : (string Regexp_types.t)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\natom_expr -> basic_atom LBRACE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_019 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 166 "lib/mik_parser.mly"
         ( missing_error "expression before '*'" _startpos _endpos )
# 603 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_020 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 167 "lib/mik_parser.mly"
         ( missing_error "expression before '+'" _startpos _endpos )
# 613 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_021 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 168 "lib/mik_parser.mly"
             ( missing_error "expression before '?'" _startpos _endpos )
# 623 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_022 =
  fun _1 _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 171 "lib/mik_parser.mly"
                 (
      to_pcre_regex _1 _startpos _endpos
    )
# 635 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_023 =
  fun _1 _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 174 "lib/mik_parser.mly"
                   (
      to_pcre_regex _1 _startpos _endpos
    )
# 647 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_024 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 177 "lib/mik_parser.mly"
              (
      to_pcre_regex "" _startpos _endpos
    )
# 659 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_025 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 180 "lib/mik_parser.mly"
               (
      to_pcre_regex "." _startpos _endpos
    )
# 671 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_026 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 183 "lib/mik_parser.mly"
          (
      to_pcre_regex "^" _startpos _endpos
    )
# 683 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_027 =
  fun _1 _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 186 "lib/mik_parser.mly"
                     (
      to_pcre_regex _1 _startpos _endpos
    )
# 695 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_028 =
  fun _1 _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 189 "lib/mik_parser.mly"
                      (
      let ident_loc = wrap_loc _startpos _endpos (string_to_longident _1) in
      wrap_loc _startpos _endpos (Call ident_loc)
    )
# 708 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_029 =
  fun _1 _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _startpos = _startpos__1_ in
    (
# 189 "lib/mik_parser.mly"
                      (
      let ident_loc = wrap_loc _startpos _endpos (string_to_longident _1) in
      wrap_loc _startpos _endpos (Call ident_loc)
    )
# 721 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_030 =
  fun _2 _endpos__3_ _startpos__1_ ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos__1_ in
    (
# 194 "lib/mik_parser.mly"
                               (
      let set_str = "[" ^ _2 ^ "]" in
      to_pcre_regex set_str _startpos _endpos
    )
# 734 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_031 =
  fun _3 _endpos__4_ _startpos__1_ ->
    let _endpos = _endpos__4_ in
    let _startpos = _startpos__1_ in
    (
# 198 "lib/mik_parser.mly"
                                     (
      let set_str = "[^" ^ _3 ^ "]" in
      to_pcre_regex set_str _startpos _endpos
    )
# 747 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_032 =
  fun _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 202 "lib/mik_parser.mly"
                      ( missing_error "character set content" _startpos _endpos )
# 757 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_033 =
  fun _endpos__3_ _startpos__1_ ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos__1_ in
    (
# 203 "lib/mik_parser.mly"
                            ( missing_error "character set content after '^'" _startpos _endpos )
# 767 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_034 =
  fun _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    (
# 204 "lib/mik_parser.mly"
                      ( unclosed_error "character set (missing ']')" _startpos__1_ _endpos )
# 776 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_035 =
  fun _endpos__2_ _startpos__1_ ->
    let _ = let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 205 "lib/mik_parser.mly"
                   ( syntax_error "Invalid character set" _startpos _endpos )
# 786 "lib/mik_parser.ml"
     : (string Regexp_types.t)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nbasic_atom -> LBRACKET error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_036 =
  fun _endpos__3_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos__1_ in
    (
# 211 "lib/mik_parser.mly"
                                 (
      (* (word) -> captures the result of calling 'word' pattern *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ (last_component id) in
      wrap_loc _startpos _endpos (Capture_as (name_loc, None, call_node))
    )
# 804 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_037 =
  fun _endpos__3_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos__1_ in
    (
# 211 "lib/mik_parser.mly"
                                 (
      (* (word) -> captures the result of calling 'word' pattern *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ (last_component id) in
      wrap_loc _startpos _endpos (Capture_as (name_loc, None, call_node))
    )
# 820 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_038 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 221 "lib/mik_parser.mly"
                                                     (
      (* (digits : int) -> captures 'digits' pattern as 'digits' converted to int *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Int, call_node))
    )
# 836 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_039 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 221 "lib/mik_parser.mly"
                                                     (
      (* (digits : int) -> captures 'digits' pattern as 'digits' converted to int *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Int, call_node))
    )
# 852 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_040 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 229 "lib/mik_parser.mly"
                                                       (
      (* (number : float) -> captures 'number' pattern as 'number' converted to float *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Float, call_node))
    )
# 868 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_041 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 229 "lib/mik_parser.mly"
                                                       (
      (* (number : float) -> captures 'number' pattern as 'number' converted to float *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Float, call_node))
    )
# 884 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_042 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id typ ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 237 "lib/mik_parser.mly"
                                                   (
      (* (text : typ) -> captures 'text' pattern converted to 'typ' given that there is a parse_<typ> function in scope *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Typ typ), call_node))
    )
# 901 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_043 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id typ ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 237 "lib/mik_parser.mly"
                                                   (
      (* (text : typ) -> captures 'text' pattern converted to 'typ' given that there is a parse_<typ> function in scope *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Typ typ), call_node))
    )
# 918 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_044 =
  fun _endpos__6_ _endpos_id_ _startpos__1_ _startpos_id_ func id ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos__1_ in
    (
# 246 "lib/mik_parser.mly"
                                                          (
      (* (text := process) -> captures 'text' pattern as 'text' processed by function *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, None)), call_node))
    )
# 935 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_045 =
  fun _endpos__6_ _endpos_id_ _startpos__1_ _startpos_id_ func id ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos__1_ in
    (
# 246 "lib/mik_parser.mly"
                                                          (
      (* (text := process) -> captures 'text' pattern as 'text' processed by function *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, None)), call_node))
    )
# 952 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_046 =
  fun _endpos__8_ _endpos_id_ _startpos__1_ _startpos_id_ func id typ ->
    let _endpos = _endpos__8_ in
    let _startpos = _startpos__1_ in
    (
# 255 "lib/mik_parser.mly"
                                                                            (
      (* (text := process : typ) -> captures 'text' pattern as 'text' processed by function, with result as type 'typ' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let func = string_to_longident func in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, Some typ)), call_node))
    )
# 970 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_047 =
  fun _endpos__8_ _endpos_id_ _startpos__1_ _startpos_id_ func id typ ->
    let _endpos = _endpos__8_ in
    let _startpos = _startpos__1_ in
    (
# 255 "lib/mik_parser.mly"
                                                                            (
      (* (text := process : typ) -> captures 'text' pattern as 'text' processed by function, with result as type 'typ' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_id_ _endpos_id_ id in
      let func = string_to_longident func in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, Some typ)), call_node))
    )
# 988 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_048 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 266 "lib/mik_parser.mly"
                                                        ( missing_error "name after 'as'" _startpos__3_ _endpos__4_ )
# 996 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_049 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 266 "lib/mik_parser.mly"
                                                        ( missing_error "name after 'as'" _startpos__3_ _endpos__4_ )
# 1004 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_050 =
  fun _endpos__5_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 268 "lib/mik_parser.mly"
                                                 (
      (* (word as w) -> captures the result of calling 'word' as 'w' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, None, call_node))
    )
# 1020 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_051 =
  fun _endpos__5_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 268 "lib/mik_parser.mly"
                                                 (
      (* (word as w) -> captures the result of calling 'word' as 'w' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, None, call_node))
    )
# 1036 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_052 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 280 "lib/mik_parser.mly"
                                               (
      missing_error "type converter after ':'" _startpos__5_ _endpos__6_ 
    )
# 1046 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_053 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 280 "lib/mik_parser.mly"
                                               (
      missing_error "type converter after ':'" _startpos__5_ _endpos__6_ 
    )
# 1056 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_054 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 280 "lib/mik_parser.mly"
                                               (
      missing_error "type converter after ':'" _startpos__5_ _endpos__6_ 
    )
# 1066 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_055 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 280 "lib/mik_parser.mly"
                                               (
      missing_error "type converter after ':'" _startpos__5_ _endpos__6_ 
    )
# 1076 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_056 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 285 "lib/mik_parser.mly"
                                                                     (
      (* (digits as n : int) -> captures 'digits' pattern as 'n' converted to int *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Int, call_node))
    )
# 1092 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_057 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 285 "lib/mik_parser.mly"
                                                                     (
      (* (digits as n : int) -> captures 'digits' pattern as 'n' converted to int *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Int, call_node))
    )
# 1108 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_058 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 293 "lib/mik_parser.mly"
                                                                       (
      (* (number as f : float) -> captures 'number' pattern as 'f' converted to float *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Float, call_node))
    )
# 1124 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_059 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 293 "lib/mik_parser.mly"
                                                                       (
      (* (number as f : float) -> captures 'number' pattern as 'f' converted to float *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Float, call_node))
    )
# 1140 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_060 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name typ ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 301 "lib/mik_parser.mly"
                                                                   (
      (* (text : typ) -> captures 'text' pattern converted to 'typ' given that there is a parse_<typ> function in scope *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Typ typ), call_node))
    )
# 1157 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_061 =
  fun _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name typ ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 301 "lib/mik_parser.mly"
                                                                   (
      (* (text : typ) -> captures 'text' pattern converted to 'typ' given that there is a parse_<typ> function in scope *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Typ typ), call_node))
    )
# 1174 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_062 =
  fun _endpos__8_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name ->
    let _endpos = _endpos__8_ in
    let _startpos = _startpos__1_ in
    (
# 310 "lib/mik_parser.mly"
                                                                          (
      (* (text as t := process) -> captures 'text' pattern as 't' processed by function *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, None)), call_node))
    )
# 1191 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_063 =
  fun _endpos__8_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name ->
    let _endpos = _endpos__8_ in
    let _startpos = _startpos__1_ in
    (
# 310 "lib/mik_parser.mly"
                                                                          (
      (* (text as t := process) -> captures 'text' pattern as 't' processed by function *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, None)), call_node))
    )
# 1208 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_064 =
  fun _endpos__10_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name typ ->
    let _endpos = _endpos__10_ in
    let _startpos = _startpos__1_ in
    (
# 319 "lib/mik_parser.mly"
                                                                                            (
      (* (text as t := process : typ) -> captures 'text' pattern as 't' processed by function, with result as type 'typ' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, Some typ)), call_node))
    )
# 1226 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_065 =
  fun _endpos__10_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name typ ->
    let _endpos = _endpos__10_ in
    let _startpos = _startpos__1_ in
    (
# 319 "lib/mik_parser.mly"
                                                                                            (
      (* (text as t := process : typ) -> captures 'text' pattern as 't' processed by function, with result as type 'typ' *)
      let call_loc = wrap_loc _startpos_id_ _endpos_id_ (string_to_longident id) in
      let call_node = wrap_loc _startpos_id_ _endpos_id_ (Call call_loc) in
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, Some typ)), call_node))
    )
# 1244 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_066 =
  fun _endpos__4_ _startpos__1_ ->
    (
# 331 "lib/mik_parser.mly"
                                   (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__4_
    )
# 1254 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_067 =
  fun _endpos__4_ _startpos__1_ ->
    (
# 331 "lib/mik_parser.mly"
                                   (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__4_
    )
# 1264 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_068 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 335 "lib/mik_parser.mly"
                                                       (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1274 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_069 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 335 "lib/mik_parser.mly"
                                                       (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1284 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_070 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 339 "lib/mik_parser.mly"
                                                         (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1294 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_071 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 339 "lib/mik_parser.mly"
                                                         (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1304 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_072 =
  fun _2 ->
    (
# 346 "lib/mik_parser.mly"
                          (
      _2
    )
# 1314 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_073 =
  fun _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 349 "lib/mik_parser.mly"
                  ( missing_error "pattern inside parentheses" _startpos _endpos )
# 1324 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_074 =
  fun _endpos__2_ _startpos__1_ ->
    (
# 350 "lib/mik_parser.mly"
                        ( unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__2_ )
# 1332 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_075 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 353 "lib/mik_parser.mly"
                             ( missing_error "capture name after 'as'" _startpos__3_ _endpos__4_ )
# 1340 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_076 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 354 "lib/mik_parser.mly"
                            (
      missing_error "capture name between 'as' and ':'" _startpos__3_ _endpos__4_
    )
# 1350 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_077 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 357 "lib/mik_parser.mly"
                                                 (
      missing_error "capture name between 'as' and ':'" _startpos__3_ _endpos__4_
    )
# 1360 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_078 =
  fun _endpos__4_ _startpos__3_ ->
    (
# 360 "lib/mik_parser.mly"
                                                   (
      missing_error "capture name between 'as' and ':'" _startpos__3_ _endpos__4_
    )
# 1370 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_079 =
  fun _endpos__5_ _startpos__3_ ->
    (
# 363 "lib/mik_parser.mly"
                                               (
      missing_error "capture name between 'as' and ':='" _startpos__3_ _endpos__5_
    )
# 1380 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_080 =
  fun _endpos__5_ _startpos__3_ ->
    (
# 366 "lib/mik_parser.mly"
                                                           (
      missing_error "capture name between 'as' and ':='" _startpos__3_ _endpos__5_
    )
# 1390 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_081 =
  fun _2 _endpos__5_ _endpos_name_ _startpos__1_ _startpos_name_ name ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 370 "lib/mik_parser.mly"
                                          (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, None, _2))
    )
# 1403 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_082 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 376 "lib/mik_parser.mly"
                                         (
      missing_error "type converter after ':'" _startpos__5_ _endpos__6_
    )
# 1413 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_083 =
  fun _endpos__6_ _startpos__5_ ->
    (
# 379 "lib/mik_parser.mly"
                                               (
      missing_error "function name after ':='" _startpos__5_ _endpos__6_
    )
# 1423 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_084 =
  fun _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 383 "lib/mik_parser.mly"
                                                              (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Int, _2))
    )
# 1436 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_085 =
  fun _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 387 "lib/mik_parser.mly"
                                                                (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some Float, _2))
    )
# 1449 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_086 =
  fun _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name typ ->
    let _endpos = _endpos__7_ in
    let _startpos = _startpos__1_ in
    (
# 391 "lib/mik_parser.mly"
                                                            (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Typ typ), _2))
    )
# 1463 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_087 =
  fun _2 _endpos__8_ _endpos_name_ _startpos__1_ _startpos_name_ func name ->
    let _endpos = _endpos__8_ in
    let _startpos = _startpos__1_ in
    (
# 396 "lib/mik_parser.mly"
                                                                   (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, None)), _2))
    )
# 1477 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_088 =
  fun _2 _endpos__10_ _endpos_name_ _startpos__1_ _startpos_name_ func name typ ->
    let _endpos = _endpos__10_ in
    let _startpos = _startpos__1_ in
    (
# 401 "lib/mik_parser.mly"
                                                                                     (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      let typ = string_to_longident typ in
      wrap_loc _startpos _endpos (Capture_as (name_loc, Some (Func (func, Some typ)), _2))
    )
# 1492 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_089 =
  fun _endpos__4_ _startpos__1_ ->
    (
# 408 "lib/mik_parser.mly"
                                 (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__4_
    )
# 1502 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_090 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 411 "lib/mik_parser.mly"
                                                     (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1512 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_091 =
  fun _endpos__6_ _startpos__1_ ->
    (
# 414 "lib/mik_parser.mly"
                                                       (
      unclosed_error "parentheses (missing ')')" _startpos__1_ _endpos__6_
    )
# 1522 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_092 =
  fun _endpos__2_ _startpos__2_ ->
    let _ = let _endpos = _endpos__2_ in
    (
# 419 "lib/mik_parser.mly"
                 ( syntax_error "Invalid expression in parentheses" _startpos__2_ _endpos )
# 1531 "lib/mik_parser.ml"
     : (string Regexp_types.t)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nbasic_atom -> LPAREN error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_093 =
  fun _1 ->
    (
# 426 "lib/mik_parser.mly"
                  ( _1 )
# 1541 "lib/mik_parser.ml"
     : (string))

let _menhir_action_094 =
  fun _1 _2 ->
    (
# 427 "lib/mik_parser.mly"
                           ( _1 ^ _2 )
# 1549 "lib/mik_parser.ml"
     : (string))

let _menhir_action_095 =
  fun _1 ->
    (
# 430 "lib/mik_parser.mly"
                 ( _1 )
# 1557 "lib/mik_parser.ml"
     : (string))

let _menhir_action_096 =
  fun _1 _3 ->
    (
# 431 "lib/mik_parser.mly"
                                   ( _1 ^ "-" ^ _3 )
# 1565 "lib/mik_parser.ml"
     : (string))

let _menhir_action_097 =
  fun _endpos__2_ _startpos__2_ ->
    let _endpos = _endpos__2_ in
    (
# 432 "lib/mik_parser.mly"
                      ( missing_error "character after '-' in range" _startpos__2_ _endpos )
# 1574 "lib/mik_parser.ml"
     : (string))

let _menhir_action_098 =
  fun _1 ->
    (
# 433 "lib/mik_parser.mly"
                   ( _1 )
# 1582 "lib/mik_parser.ml"
     : (string))

let _menhir_action_099 =
  fun _1 ->
    (
# 434 "lib/mik_parser.mly"
        ( _1 )
# 1590 "lib/mik_parser.ml"
     : (string))

let _menhir_action_100 =
  fun _1 ->
    (
# 435 "lib/mik_parser.mly"
                     ( _1 )
# 1598 "lib/mik_parser.ml"
     : (string))

let _menhir_action_101 =
  fun _1 ->
    (
# 436 "lib/mik_parser.mly"
          ( _1 )
# 1606 "lib/mik_parser.ml"
     : (string))

let _menhir_action_102 =
  fun _1 _3 _endpos__3_ _startpos__2_ ->
    let _endpos = _endpos__3_ in
    (
# 437 "lib/mik_parser.mly"
                     (
      if String.length _1 = 1 && String.length _3 = 1 then
        _1 ^ "-" ^ _3
      else
        syntax_error "ranges must be single characters" _startpos__2_ _endpos
    )
# 1620 "lib/mik_parser.ml"
     : (string))

let _menhir_action_103 =
  fun _1 ->
    (
# 422 "lib/mik_parser.mly"
          ( _1 )
# 1628 "lib/mik_parser.ml"
     : (string))

let _menhir_action_104 =
  fun _1 ->
    (
# 423 "lib/mik_parser.mly"
              ( _1 )
# 1636 "lib/mik_parser.ml"
     : (string))

let _menhir_action_105 =
  fun p ->
    (
# 101 "lib/mik_parser.mly"
                    ( p, mikmatch_default_flags )
# 1644 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags))

let _menhir_action_106 =
  fun p ->
    (
# 87 "lib/mik_parser.mly"
                    (
      p, mikmatch_default_flags
    )
# 1654 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags))

let _menhir_action_107 =
  fun p ->
    (
# 90 "lib/mik_parser.mly"
                                (
      p, mikmatch_default_flags
    )
# 1664 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags))

let _menhir_action_108 =
  fun _endpos_flags_ _startpos_flags_ flags p ->
    (
# 93 "lib/mik_parser.mly"
                                              (
      p, parse_flags flags _startpos_flags_ _endpos_flags_
    )
# 1674 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags))

let _menhir_action_109 =
  fun _endpos__3_ _startpos__1_ ->
    let _endpos = _endpos__3_ in
    (
# 96 "lib/mik_parser.mly"
                      ( unclosed_error "pattern (missing closing '/')" _startpos__1_ _endpos )
# 1683 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags))

let _menhir_action_110 =
  fun _endpos__2_ _startpos__2_ ->
    let _ = (
# 97 "lib/mik_parser.mly"
                ( syntax_error "Invalid pattern after opening slash" _startpos__2_ _endpos__2_ )
# 1691 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nmain_match_case -> SLASH error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_111 =
  fun _endpos__1_ _startpos__1_ ->
    let _ = (
# 98 "lib/mik_parser.mly"
          ( syntax_error "Expected pattern to start with '/'" _startpos__1_ _endpos__1_ )
# 1701 "lib/mik_parser.ml"
     : (string Regexp_types.t * Regexp_types.flags)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nmain_match_case -> error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_112 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 1711 "lib/mik_parser.ml"
     : (unit option))

let _menhir_action_113 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 1719 "lib/mik_parser.ml"
     : (unit option))

let _menhir_action_114 =
  fun _1 ->
    (
# 104 "lib/mik_parser.mly"
             ( _1 )
# 1727 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_115 =
  fun _1 _endpos_name_ _startpos__1_ _startpos_name_ func name ->
    let _endpos = _endpos_name_ in
    let _startpos = _startpos__1_ in
    (
# 105 "lib/mik_parser.mly"
                                               (
      let name_loc = wrap_loc _startpos_name_ _endpos_name_ name in
      let func = string_to_longident func in
      wrap_loc _startpos _endpos (Pipe_all (name_loc, func, _1))
    )
# 1741 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_116 =
  fun _endpos__2_ _startpos__2_ ->
    let _endpos = _endpos__2_ in
    (
# 110 "lib/mik_parser.mly"
                  ( missing_error "function name after '>>>'" _startpos__2_ _endpos )
# 1750 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_117 =
  fun _endpos__3_ _startpos__3_ ->
    let _endpos = _endpos__3_ in
    (
# 111 "lib/mik_parser.mly"
                        ( missing_error "'as' and result name after function" _startpos__3_ _endpos )
# 1759 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_118 =
  fun _endpos__4_ _startpos__4_ ->
    let _endpos = _endpos__4_ in
    (
# 112 "lib/mik_parser.mly"
                           ( missing_error "result name after 'as'" _startpos__4_ _endpos )
# 1768 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_119 =
  fun _endpos__0_ ->
    let _endpos = _endpos__0_ in
    let _startpos = _endpos__0_ in
    (
# 113 "lib/mik_parser.mly"
    ( missing_error "pattern expression" _startpos _endpos )
# 1778 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_120 =
  fun _1 ->
    (
# 125 "lib/mik_parser.mly"
              ( _1 )
# 1786 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_action_121 =
  fun _1 _2 _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 126 "lib/mik_parser.mly"
                                 (
      let loc = make_loc _startpos _endpos in
      simplify_seq ~loc [_1; _2]
    )
# 1799 "lib/mik_parser.ml"
     : (string Regexp_types.t))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | UNDERSCORE ->
        "UNDERSCORE"
    | TILDE ->
        "TILDE"
    | STRING_LITERAL _ ->
        "STRING_LITERAL"
    | STAR ->
        "STAR"
    | SLASH ->
        "SLASH"
    | RPAREN ->
        "RPAREN"
    | RBRACKET ->
        "RBRACKET"
    | RBRACE ->
        "RBRACE"
    | QUESTION ->
        "QUESTION"
    | PREDEFINED_CLASS _ ->
        "PREDEFINED_CLASS"
    | PLUS ->
        "PLUS"
    | PIPE ->
        "PIPE"
    | MOD_IDENT _ ->
        "MOD_IDENT"
    | LPAREN ->
        "LPAREN"
    | LBRACKET ->
        "LBRACKET"
    | LBRACE ->
        "LBRACE"
    | INT_CONVERTER ->
        "INT_CONVERTER"
    | INT _ ->
        "INT"
    | IDENT _ ->
        "IDENT"
    | FLOAT_CONVERTER ->
        "FLOAT_CONVERTER"
    | EQUAL ->
        "EQUAL"
    | EOF ->
        "EOF"
    | EMPTY_STR ->
        "EMPTY_STR"
    | DASH ->
        "DASH"
    | COLON ->
        "COLON"
    | CHAR_LITERAL _ ->
        "CHAR_LITERAL"
    | CARET ->
        "CARET"
    | BAR ->
        "BAR"
    | AS ->
        "AS"

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_178 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main_let_expr =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let p = _v in
          let _v = _menhir_action_105 p in
          MenhirBox_main_let_expr _v
      | _ ->
          _eRR ()
  
  let _menhir_goto_main_match_case : type  ttv_stack. ttv_stack -> _ -> _menhir_box_main_match_case =
    fun _menhir_stack _v ->
      MenhirBox_main_match_case _v
  
  let _menhir_run_185 : type  ttv_stack. (ttv_stack, _menhir_box_main_match_case) _menhir_cell1_SLASH -> _ -> _ -> _ -> _ -> _menhir_box_main_match_case =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | SLASH ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _v_0 ->
              let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | EOF ->
                  let MenhirCell1_SLASH (_menhir_stack, _, _) = _menhir_stack in
                  let (p, _endpos_flags_, _startpos_flags_, flags) = (_v, _endpos_2, _startpos_1, _v_0) in
                  let _v = _menhir_action_108 _endpos_flags_ _startpos_flags_ flags p in
                  _menhir_goto_main_match_case _menhir_stack _v
              | _ ->
                  _eRR ())
          | EOF ->
              let MenhirCell1_SLASH (_menhir_stack, _, _) = _menhir_stack in
              let p = _v in
              let _v = _menhir_action_107 p in
              _menhir_goto_main_match_case _menhir_stack _v
          | _ ->
              _eRR ())
      | EOF ->
          let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
          let MenhirCell1_SLASH (_menhir_stack, _, _startpos__1_) = _menhir_stack in
          let _endpos__3_ = _endpos_5 in
          let _v = _menhir_action_109 _endpos__3_ _startpos__1_ in
          _menhir_goto_main_match_case _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_run_191 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main_match_case =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let p = _v in
          let _v = _menhir_action_106 p in
          _menhir_goto_main_match_case _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_run_195 : type  ttv_stack. ttv_stack -> _ -> _menhir_box_pattern =
    fun _menhir_stack _v ->
      MenhirBox_pattern _v
  
  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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_025 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_basic_atom : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | TILDE ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _1, _endpos__2_) = (_startpos, _v, _endpos_0) in
          let _v = _menhir_action_011 _1 _endpos__2_ _startpos__1_ in
          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | STAR ->
          let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _1, _endpos__2_, _startpos__2_) = (_startpos, _v, _endpos_2, _startpos_1) in
          let _v = _menhir_action_008 _1 _endpos__2_ _startpos__1_ _startpos__2_ in
          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | QUESTION ->
          let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _1, _endpos__2_) = (_startpos, _v, _endpos_4) in
          let _v = _menhir_action_010 _1 _endpos__2_ _startpos__1_ in
          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | PLUS ->
          let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _1, _endpos__2_, _startpos__2_) = (_startpos, _v, _endpos_6, _startpos_5) in
          let _v = _menhir_action_009 _1 _endpos__2_ _startpos__1_ _startpos__2_ in
          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | LBRACE ->
          let _startpos_7 = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RBRACE ->
              let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos__1_, _startpos__2_, _endpos__3_) = (_startpos, _startpos_7, _endpos_8) in
              let _v = _menhir_action_015 _endpos__3_ _startpos__2_ in
              _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
          | INT _v_9 ->
              let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RBRACE ->
                  let _endpos_11 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_startpos__1_, _1, _startpos__2_, _endpos__4_, n) = (_startpos, _v, _startpos_7, _endpos_11, _v_9) in
                  let _v = _menhir_action_012 _1 _endpos__4_ _startpos__1_ _startpos__2_ n in
                  _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
              | DASH ->
                  let _startpos_12 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RBRACE ->
                      let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _1, _startpos__2_, _endpos__5_, min) = (_startpos, _v, _startpos_7, _endpos_14, _v_9) in
                      let _v = _menhir_action_014 _1 _endpos__5_ _startpos__1_ _startpos__2_ min in
                      _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | INT _v_15 ->
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RBRACE ->
                          let _endpos_17 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let (_startpos__1_, _1, _startpos__2_, _endpos__6_, min, max) = (_startpos, _v, _startpos_7, _endpos_17, _v_9, _v_15) in
                          let _v = _menhir_action_013 _1 _endpos__6_ _startpos__1_ _startpos__2_ max min in
                          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                      | _ ->
                          _eRR ())
                  | DASH ->
                      let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _startpos__4_, _endpos__5_) = (_startpos, _startpos_12, _endpos_19) in
                      let _v = _menhir_action_016 _endpos__5_ _startpos__4_ in
                      _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                  let (_startpos__1_, _startpos__2_, _endpos__3_) = (_startpos, _startpos_7, _endpos_10) in
                  let _v = _menhir_action_017 _endpos__3_ _startpos__2_ in
                  _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              let _endpos_21 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__2_, _endpos__3_) = (_startpos_7, _endpos_21) in
              let _ = _menhir_action_018 _endpos__3_ _startpos__2_ in
              _eRR ())
      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PREDEFINED_CLASS _ | RPAREN | SLASH | STRING_LITERAL _ | UNDERSCORE ->
          let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_007 _1 in
          _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_atom_expr : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | STRING_LITERAL _v_0 ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState134
      | STAR ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | QUESTION ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | PREDEFINED_CLASS _v_1 ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState134
      | PLUS ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | MOD_IDENT _v_2 ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState134
      | LPAREN ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | LBRACKET ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | IDENT _v_3 ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState134
      | EMPTY_STR ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | CHAR_LITERAL _v_4 ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState134
      | CARET ->
          let _menhir_stack = MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | AS | BAR | EOF | LBRACE | PIPE | RPAREN | SLASH | TILDE ->
          let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_120 _1 in
          _menhir_goto_seq_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_002 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_023 _1 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_019 _endpos__1_ _startpos__1_ in
      _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_021 _endpos__1_ _startpos__1_ in
      _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_027 _1 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_020 _endpos__1_ _startpos__1_ in
      _menhir_goto_atom_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  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 _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_029 _1 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_008 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | STRING_LITERAL _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | STAR ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | RPAREN ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos) in
          let _v = _menhir_action_073 _endpos__2_ _startpos__1_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | QUESTION ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | PREDEFINED_CLASS _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | PLUS ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | MOD_IDENT _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RPAREN ->
              let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos__1_, _endpos__3_, _endpos_id_, _startpos_id_, id) = (_startpos, _endpos_1, _endpos, _startpos_0, _v) in
              let _v = _menhir_action_037 _endpos__3_ _endpos_id_ _startpos__1_ _startpos_id_ id in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
          | COLON ->
              let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | MOD_IDENT _v_4 ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_2, _endpos_3) in
                  _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState013
              | INT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_) = (_startpos, _endpos, _startpos_0, _v, _endpos_6) in
                      let _v = _menhir_action_039 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | IDENT _v_7 ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_2, _endpos_3) in
                  _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState013
              | FLOAT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_) = (_startpos, _endpos, _startpos_0, _v, _endpos_9) in
                      let _v = _menhir_action_041 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | EQUAL ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_2, _endpos_3) in
                  let _menhir_s = MenhirState013 in
                  let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) in
                  let _menhir_s = MenhirState020 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | MOD_IDENT _v ->
                      _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | IDENT _v ->
                      _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | AS ->
              let _startpos_13 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RPAREN ->
                  let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_startpos__1_, _startpos__3_, _endpos__4_) = (_startpos, _startpos_13, _endpos_15) in
                  let _v = _menhir_action_049 _endpos__4_ _startpos__3_ in
                  _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
              | MOD_IDENT _ ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | COLON ->
                      let _startpos_19 = _menhir_lexbuf.Lexing.lex_start_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_21 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let (_startpos__1_, _startpos__5_, _endpos__6_) = (_startpos, _startpos_19, _endpos_21) in
                          let _v = _menhir_action_055 _endpos__6_ _startpos__5_ in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                      | _ ->
                          _eRR ())
                  | _ ->
                      _eRR ())
              | IDENT _v_22 ->
                  let _startpos_23 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_24 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_25 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_, _endpos_name_, _startpos_name_, name) = (_startpos, _endpos, _startpos_0, _v, _endpos_25, _endpos_24, _startpos_23, _v_22) in
                      let _v = _menhir_action_051 _endpos__5_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | EOF ->
                      let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                      let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                      let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                      _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState033
                  | COLON ->
                      let _startpos_26 = _menhir_lexbuf.Lexing.lex_start_p in
                      let _endpos_27 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let (_startpos__1_, _startpos__5_, _endpos__6_) = (_startpos, _startpos_26, _endpos_28) in
                          let _v = _menhir_action_054 _endpos__6_ _startpos__5_ in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                      | MOD_IDENT _v_29 ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_29 MenhirState036
                      | INT_CONVERTER ->
                          let _endpos_30 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | RPAREN ->
                              let _endpos_31 = _menhir_lexbuf.Lexing.lex_curr_p in
                              let _tok = _menhir_lexer _menhir_lexbuf in
                              let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_startpos, _endpos, _startpos_0, _v, _endpos_24, _startpos_23, _v_22, _endpos_31) in
                              let _v = _menhir_action_057 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                          | EOF ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                              let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState036, _endpos_30) in
                              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState038
                          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                              let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState036, _endpos_30) in
                              let _ = _menhir_action_112 () in
                              _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_30 _tok
                          | _ ->
                              _eRR ())
                      | IDENT _v_33 ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_33 MenhirState036
                      | FLOAT_CONVERTER ->
                          let _endpos_34 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | RPAREN ->
                              let _endpos_35 = _menhir_lexbuf.Lexing.lex_curr_p in
                              let _tok = _menhir_lexer _menhir_lexbuf in
                              let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_startpos, _endpos, _startpos_0, _v, _endpos_24, _startpos_23, _v_22, _endpos_35) in
                              let _v = _menhir_action_059 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                          | EOF ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                              let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState036, _endpos_34) in
                              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState041
                          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                              let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState036, _endpos_34) in
                              let _ = _menhir_action_112 () in
                              _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_34 _tok
                          | _ ->
                              _eRR ())
                      | EQUAL ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState033, _startpos_26, _endpos_27) in
                          let _menhir_s = MenhirState036 in
                          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) in
                          let _menhir_s = MenhirState044 in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | MOD_IDENT _v ->
                              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                          | IDENT _v ->
                              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                          | _ ->
                              _eRR ())
                      | _ ->
                          _eRR ())
                  | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                      let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                      let _menhir_stack = MenhirCell1_MOD_IDENT (_menhir_stack, MenhirState008, _v, _startpos_0, _endpos) in
                      let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_13, _endpos_14) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_22, _startpos_23, _endpos_24) in
                      let _ = _menhir_action_112 () in
                      _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_24 _tok
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
              let (_menhir_s, _endpos__1_, _startpos__1_, _1) = (MenhirState008, _endpos, _startpos_0, _v) in
              let _v = _menhir_action_029 _1 _endpos__1_ _startpos__1_ in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | LPAREN ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | LBRACKET ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | IDENT _v ->
          let _startpos_41 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RPAREN ->
              let _endpos_42 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos__1_, _endpos__3_, _endpos_id_, _startpos_id_, id) = (_startpos, _endpos_42, _endpos, _startpos_41, _v) in
              let _v = _menhir_action_036 _endpos__3_ _endpos_id_ _startpos__1_ _startpos_id_ id in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
          | COLON ->
              let _startpos_43 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_44 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | MOD_IDENT _v_45 ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_43, _endpos_44) in
                  _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_45 MenhirState075
              | INT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_47 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_) = (_startpos, _endpos, _startpos_41, _v, _endpos_47) in
                      let _v = _menhir_action_038 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | IDENT _v_48 ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_43, _endpos_44) in
                  _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_48 MenhirState075
              | FLOAT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_50 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_) = (_startpos, _endpos, _startpos_41, _v, _endpos_50) in
                      let _v = _menhir_action_040 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | EQUAL ->
                  let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                  let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_43, _endpos_44) in
                  let _menhir_s = MenhirState075 in
                  let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) in
                  let _menhir_s = MenhirState080 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | MOD_IDENT _v ->
                      _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | IDENT _v ->
                      _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | AS ->
              let _startpos_54 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_55 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RPAREN ->
                  let _endpos_56 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_startpos__1_, _startpos__3_, _endpos__4_) = (_startpos, _startpos_54, _endpos_56) in
                  let _v = _menhir_action_048 _endpos__4_ _startpos__3_ in
                  _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
              | MOD_IDENT _ ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | COLON ->
                      let _startpos_60 = _menhir_lexbuf.Lexing.lex_start_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_62 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let (_startpos__1_, _startpos__5_, _endpos__6_) = (_startpos, _startpos_60, _endpos_62) in
                          let _v = _menhir_action_053 _endpos__6_ _startpos__5_ in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                      | _ ->
                          _eRR ())
                  | _ ->
                      _eRR ())
              | IDENT _v_63 ->
                  let _startpos_64 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_65 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_66 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos__5_, _endpos_name_, _startpos_name_, name) = (_startpos, _endpos, _startpos_41, _v, _endpos_66, _endpos_65, _startpos_64, _v_63) in
                      let _v = _menhir_action_050 _endpos__5_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
                  | EOF ->
                      let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                      let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                      let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                      _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState093
                  | COLON ->
                      let _startpos_67 = _menhir_lexbuf.Lexing.lex_start_p in
                      let _endpos_68 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_69 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let (_startpos__1_, _startpos__5_, _endpos__6_) = (_startpos, _startpos_67, _endpos_69) in
                          let _v = _menhir_action_052 _endpos__6_ _startpos__5_ in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                      | MOD_IDENT _v_70 ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_70 MenhirState095
                      | INT_CONVERTER ->
                          let _endpos_71 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | RPAREN ->
                              let _endpos_72 = _menhir_lexbuf.Lexing.lex_curr_p in
                              let _tok = _menhir_lexer _menhir_lexbuf in
                              let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_startpos, _endpos, _startpos_41, _v, _endpos_65, _startpos_64, _v_63, _endpos_72) in
                              let _v = _menhir_action_056 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                          | EOF ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                              let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState095, _endpos_71) in
                              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
                          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                              let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState095, _endpos_71) in
                              let _ = _menhir_action_112 () in
                              _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_71 _tok
                          | _ ->
                              _eRR ())
                      | IDENT _v_74 ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_74 MenhirState095
                      | FLOAT_CONVERTER ->
                          let _endpos_75 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | RPAREN ->
                              let _endpos_76 = _menhir_lexbuf.Lexing.lex_curr_p in
                              let _tok = _menhir_lexer _menhir_lexbuf in
                              let (_startpos__1_, _endpos_id_, _startpos_id_, id, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_startpos, _endpos, _startpos_41, _v, _endpos_65, _startpos_64, _v_63, _endpos_76) in
                              let _v = _menhir_action_058 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name in
                              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                          | EOF ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                              let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState095, _endpos_75) in
                              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState100
                          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                              let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                              let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                              let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                              let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState095, _endpos_75) in
                              let _ = _menhir_action_112 () in
                              _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_75 _tok
                          | _ ->
                              _eRR ())
                      | EQUAL ->
                          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                          let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState093, _startpos_67, _endpos_68) in
                          let _menhir_s = MenhirState095 in
                          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, _menhir_s, _endpos) in
                          let _menhir_s = MenhirState103 in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          (match (_tok : MenhirBasics.token) with
                          | MOD_IDENT _v ->
                              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                          | IDENT _v ->
                              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                          | _ ->
                              _eRR ())
                      | _ ->
                          _eRR ())
                  | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                      let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
                      let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState008, _v, _startpos_41, _endpos) in
                      let _menhir_stack = MenhirCell0_AS (_menhir_stack, _startpos_54, _endpos_55) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_63, _startpos_64, _endpos_65) in
                      let _ = _menhir_action_112 () in
                      _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_65 _tok
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
              let (_menhir_s, _endpos__1_, _startpos__1_, _1) = (MenhirState008, _endpos, _startpos_41, _v) in
              let _v = _menhir_action_028 _1 _endpos__1_ _startpos__1_ in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | EMPTY_STR ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | CHAR_LITERAL _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | CARET ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | BAR ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState008
      | AS | EOF | LBRACE | PIPE | SLASH | TILDE ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          let _v =
            let _endpos__0_ = _endpos in
            _menhir_action_119 _endpos__0_
          in
          _menhir_run_137 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v MenhirState008 _tok
      | _ ->
          let _startpos_82 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_endpos__2_, _startpos__2_) = (_endpos, _startpos_82) in
          let _ = _menhir_action_092 _endpos__2_ _startpos__2_ in
          _eRR ()
  
  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 _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_104 _1 in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _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 _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState020 ->
          _menhir_run_021 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState023 ->
          _menhir_run_024 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState013 ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState044 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState047 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState036 ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState080 ->
          _menhir_run_081 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState083 ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState075 ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState103 ->
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState106 ->
          _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState095 ->
          _menhir_run_109 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState151 ->
          _menhir_run_153 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState155 ->
          _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState143 ->
          _menhir_run_158 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState166 ->
          _menhir_run_167 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState169 ->
          _menhir_run_170 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState174 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_021 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON, ttv_result) _menhir_cell1_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__6_, func) = (_endpos_0, _v) in
          let _v = _menhir_action_045 _endpos__6_ _endpos_id_ _startpos__1_ _startpos_id_ func id in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState023 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_017 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_103 _1 in
      _menhir_goto_ident _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_024 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON, ttv_result) _menhir_cell1_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, func, _, _) = _menhir_stack in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__8_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_047 _endpos__8_ _endpos_id_ _startpos__1_ _startpos_id_ func id typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_026 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__5_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_043 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_045 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (func, _endpos__8_) = (_v, _endpos_0) in
          let _v = _menhir_action_063 _endpos__8_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState047 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_048 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, func, _, _) = _menhir_stack in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (typ, _endpos__10_) = (_v, _endpos_0) in
          let _v = _menhir_action_065 _endpos__10_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__10_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_050 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_MOD_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__7_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_061 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_081 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_COLON, ttv_result) _menhir_cell1_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__6_, func) = (_endpos_0, _v) in
          let _v = _menhir_action_044 _endpos__6_ _endpos_id_ _startpos__1_ _startpos_id_ func id in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState083 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_084 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_COLON, ttv_result) _menhir_cell1_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, func, _, _) = _menhir_stack in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__8_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_046 _endpos__8_ _endpos_id_ _startpos__1_ _startpos_id_ func id typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_086 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__5_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_042 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ id typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_104 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (func, _endpos__8_) = (_v, _endpos_0) in
          let _v = _menhir_action_062 _endpos__8_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState106 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_107 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, func, _, _) = _menhir_stack in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (typ, _endpos__10_) = (_v, _endpos_0) in
          let _v = _menhir_action_064 _endpos__10_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ func id name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__10_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_109 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__7_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_060 _endpos__7_ _endpos_id_ _endpos_name_ _startpos__1_ _startpos_id_ _startpos_name_ id name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_153 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_pattern (_menhir_stack, _, _2, _) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (func, _endpos__8_) = (_v, _endpos_0) in
          let _v = _menhir_action_087 _2 _endpos__8_ _endpos_name_ _startpos__1_ _startpos_name_ func name in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState155 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_156 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, func, _, _) = _menhir_stack in
          let MenhirCell1_EQUAL (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_pattern (_menhir_stack, _, _2, _) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (typ, _endpos__10_) = (_v, _endpos_0) in
          let _v = _menhir_action_088 _2 _endpos__10_ _endpos_name_ _startpos__1_ _startpos_name_ func name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__10_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_158 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell0_IDENT (_menhir_stack, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_pattern (_menhir_stack, _, _2, _) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__7_, typ) = (_endpos_0, _v) in
          let _v = _menhir_action_086 _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name typ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_167 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_COLON _menhir_cell0_EQUAL as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_EQUAL (_menhir_stack, _endpos__5_) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_AS (_menhir_stack, _, _startpos__3_, _) = _menhir_stack in
          let MenhirCell1_pattern (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos__7_ = _endpos_0 in
          let _v = _menhir_action_079 _endpos__5_ _startpos__3_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _menhir_stack = MenhirCell1_ident (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState169 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_170 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_COLON _menhir_cell0_EQUAL, ttv_result) _menhir_cell1_ident _menhir_cell0_COLON -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_ident (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell0_EQUAL (_menhir_stack, _endpos__5_) = _menhir_stack in
          let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_AS (_menhir_stack, _, _startpos__3_, _) = _menhir_stack in
          let MenhirCell1_pattern (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos__9_ = _endpos_0 in
          let _v = _menhir_action_080 _endpos__5_ _startpos__3_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__9_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_175 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_alt_expr _menhir_cell0_PIPE -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      match (_tok : MenhirBasics.token) with
      | AS ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _v_2 ->
              let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell0_PIPE (_menhir_stack, _, _) = _menhir_stack in
              let MenhirCell1_alt_expr (_menhir_stack, _menhir_s, _1, _startpos__1_, _) = _menhir_stack in
              let (_endpos_name_, _startpos_name_, name, func) = (_endpos_4, _startpos_3, _v_2, _v) in
              let _v = _menhir_action_115 _1 _endpos_name_ _startpos__1_ _startpos_name_ func name in
              _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_name_ _v _menhir_s _tok
          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
              let MenhirCell0_PIPE (_menhir_stack, _, _) = _menhir_stack in
              let MenhirCell1_alt_expr (_menhir_stack, _menhir_s, _, _, _) = _menhir_stack in
              let (_endpos__4_, _startpos__4_) = (_endpos_1, _startpos_0) in
              let _v = _menhir_action_118 _endpos__4_ _startpos__4_ in
              _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let MenhirCell0_PIPE (_menhir_stack, _, _) = _menhir_stack in
          let MenhirCell1_alt_expr (_menhir_stack, _menhir_s, _, _, _) = _menhir_stack in
          let (_endpos__3_, _startpos__3_) = (_endpos, _startpos) in
          let _v = _menhir_action_117 _endpos__3_ _startpos__3_ in
          _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_pattern : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState008 ->
          _menhir_run_137 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState000 ->
          _menhir_run_178 _menhir_stack _v _tok
      | MenhirState183 ->
          _menhir_run_185 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState181 ->
          _menhir_run_191 _menhir_stack _v _tok
      | MenhirState194 ->
          _menhir_run_195 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_137 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_2, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_072 _2 in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | EOF ->
          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState137
      | AS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RPAREN ->
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
              let (_startpos__3_, _endpos__4_) = (_startpos, _endpos_2) in
              let _v = _menhir_action_075 _endpos__4_ _startpos__3_ in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
          | IDENT _v_3 ->
              let _startpos_4 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | RPAREN ->
                  let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                  let (_2, _endpos__5_, _endpos_name_, _startpos_name_, name) = (_v, _endpos_6, _endpos_5, _startpos_4, _v_3) in
                  let _v = _menhir_action_081 _2 _endpos__5_ _endpos_name_ _startpos__1_ _startpos_name_ name in
                  _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
              | EOF ->
                  let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                  let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                  let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                  _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
              | COLON ->
                  let _startpos_7 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                      let (_startpos__5_, _endpos__6_) = (_startpos_7, _endpos_9) in
                      let _v = _menhir_action_082 _endpos__6_ _startpos__5_ in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                  | MOD_IDENT _v_10 ->
                      let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                      let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                      let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                      _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState143
                  | INT_CONVERTER ->
                      let _endpos_11 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_12 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                          let (_2, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_v, _endpos_5, _startpos_4, _v_3, _endpos_12) in
                          let _v = _menhir_action_084 _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                      | EOF ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState143, _endpos_11) in
                          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState145
                      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_INT_CONVERTER (_menhir_stack, MenhirState143, _endpos_11) in
                          let _ = _menhir_action_112 () in
                          _menhir_run_147 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_11 _tok
                      | _ ->
                          _eRR ())
                  | IDENT _v_14 ->
                      let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                      let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                      let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                      let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                      _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 MenhirState143
                  | FLOAT_CONVERTER ->
                      let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_16 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                          let (_2, _endpos_name_, _startpos_name_, name, _endpos__7_) = (_v, _endpos_5, _startpos_4, _v_3, _endpos_16) in
                          let _v = _menhir_action_085 _2 _endpos__7_ _endpos_name_ _startpos__1_ _startpos_name_ name in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                      | EOF ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState143, _endpos_15) in
                          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState148
                      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_FLOAT_CONVERTER (_menhir_stack, MenhirState143, _endpos_15) in
                          let _ = _menhir_action_112 () in
                          _menhir_run_150 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_15 _tok
                      | _ ->
                          _eRR ())
                  | EQUAL ->
                      let _endpos_18 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      (match (_tok : MenhirBasics.token) with
                      | RPAREN ->
                          let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in
                          let _tok = _menhir_lexer _menhir_lexbuf in
                          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                          let (_startpos__5_, _endpos__6_, _endpos__7_) = (_startpos_7, _endpos_18, _endpos_19) in
                          let _v = _menhir_action_083 _endpos__6_ _startpos__5_ in
                          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
                      | MOD_IDENT _v_20 ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, MenhirState143, _endpos_18) in
                          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_20 MenhirState151
                      | IDENT _v_21 ->
                          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                          let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, MenhirState141, _startpos_7, _endpos_8) in
                          let _menhir_stack = MenhirCell1_EQUAL (_menhir_stack, MenhirState143, _endpos_18) in
                          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_21 MenhirState151
                      | _ ->
                          _eRR ())
                  | _ ->
                      _eRR ())
              | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                  let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                  let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                  let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_3, _startpos_4, _endpos_5) in
                  let _ = _menhir_action_112 () in
                  _menhir_run_160 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_5 _tok
              | _ ->
                  _eRR ())
          | COLON ->
              let _startpos_23 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_24 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | INT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_26 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                      let (_startpos__3_, _endpos__4_, _endpos__6_) = (_startpos, _endpos_24, _endpos_26) in
                      let _v = _menhir_action_077 _endpos__4_ _startpos__3_ in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | FLOAT_CONVERTER ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | RPAREN ->
                      let _endpos_28 = _menhir_lexbuf.Lexing.lex_curr_p in
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                      let (_startpos__3_, _endpos__4_, _endpos__6_) = (_startpos, _endpos_24, _endpos_28) in
                      let _v = _menhir_action_078 _endpos__4_ _startpos__3_ in
                      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos__1_ _v _menhir_s _tok
                  | _ ->
                      _eRR ())
              | EQUAL ->
                  let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
                  let _menhir_stack = MenhirCell1_AS (_menhir_stack, MenhirState137, _startpos, _endpos_1) in
                  let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_23, _endpos_24) in
                  let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _menhir_stack = MenhirCell0_EQUAL (_menhir_stack, _endpos) in
                  let _menhir_s = MenhirState166 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | MOD_IDENT _v ->
                      _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | IDENT _v ->
                      _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | _ ->
                      _eRR ())
              | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
                  let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
                  let (_startpos__3_, _endpos__4_) = (_startpos, _endpos_24) in
                  let _v = _menhir_action_076 _endpos__4_ _startpos__3_ in
                  _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v, _endpos) in
          let _ = _menhir_action_112 () in
          _menhir_run_172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_035 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_x_, x) = (_endpos, ()) in
      let _ = _menhir_action_113 x in
      _menhir_goto_option_EOF_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _menhir_s _tok
  
  and _menhir_goto_option_EOF_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _menhir_s _tok ->
      match _menhir_s with
      | MenhirState038 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState041 ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState033 ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState097 ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState100 ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState093 ->
          _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState145 ->
          _menhir_run_147 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState148 ->
          _menhir_run_150 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState141 ->
          _menhir_run_160 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState137 ->
          _menhir_run_172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_040 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_INT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_INT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_MOD_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_069 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_043 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_FLOAT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_FLOAT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_MOD_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_071 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_052 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_MOD_IDENT _menhir_cell0_AS _menhir_cell0_IDENT -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_IDENT (_menhir_stack, _, _, _endpos__4_) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_MOD_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_067 _endpos__4_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_099 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_INT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_INT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_068 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_102 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_FLOAT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_FLOAT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_070 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_111 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_IDENT _menhir_cell0_AS _menhir_cell0_IDENT -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_IDENT (_menhir_stack, _, _, _endpos__4_) = _menhir_stack in
      let MenhirCell0_AS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_066 _endpos__4_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_147 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_INT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_INT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_pattern (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_090 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_150 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT, ttv_result) _menhir_cell1_COLON, ttv_result) _menhir_cell1_FLOAT_CONVERTER -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_FLOAT_CONVERTER (_menhir_stack, _, _endpos__6_) = _menhir_stack in
      let MenhirCell1_COLON (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_pattern (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__7_ = _endpos in
      let _v = _menhir_action_091 _endpos__6_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__7_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_160 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern, ttv_result) _menhir_cell1_AS _menhir_cell0_IDENT -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_IDENT (_menhir_stack, _, _, _endpos__4_) = _menhir_stack in
      let MenhirCell1_AS (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_pattern (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_089 _endpos__4_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_172 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LPAREN, ttv_result) _menhir_cell1_pattern -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_pattern (_menhir_stack, _, _, _endpos__2_) = _menhir_stack in
      let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_074 _endpos__2_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_053 : 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
      | STRING_LITERAL _v ->
          let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState053
      | RBRACKET ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos) in
          let _v = _menhir_action_032 _endpos__2_ _startpos__1_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | PREDEFINED_CLASS _v ->
          let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState053
      | INT _v ->
          let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState053
      | IDENT _v ->
          let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState053
      | CHAR_LITERAL _v ->
          let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState053
      | CARET ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | STRING_LITERAL _v ->
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
              let _menhir_stack = MenhirCell1_CARET (_menhir_stack, MenhirState053, _startpos_0, _endpos) in
              _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState065
          | RBRACKET ->
              let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos__1_, _endpos__3_) = (_startpos, _endpos_1) in
              let _v = _menhir_action_033 _endpos__3_ _startpos__1_ in
              _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
          | PREDEFINED_CLASS _v ->
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
              let _menhir_stack = MenhirCell1_CARET (_menhir_stack, MenhirState053, _startpos_0, _endpos) in
              _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState065
          | INT _v ->
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
              let _menhir_stack = MenhirCell1_CARET (_menhir_stack, MenhirState053, _startpos_0, _endpos) in
              _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState065
          | IDENT _v ->
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
              let _menhir_stack = MenhirCell1_CARET (_menhir_stack, MenhirState053, _startpos_0, _endpos) in
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState065
          | CHAR_LITERAL _v ->
              let _menhir_stack = MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos) in
              let _menhir_stack = MenhirCell1_CARET (_menhir_stack, MenhirState053, _startpos_0, _endpos) in
              _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState065
          | _ ->
              _eRR ())
      | _ ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos) in
          let _ = _menhir_action_035 _endpos__2_ _startpos__1_ in
          _eRR ()
  
  and _menhir_run_055 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _1) = (_endpos, _v) in
      let _v = _menhir_action_098 _1 in
      _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_char_set_item : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | STRING_LITERAL _v_0 ->
          let _menhir_stack = MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState067
      | PREDEFINED_CLASS _v_1 ->
          let _menhir_stack = MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_057 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState067
      | INT _v_2 ->
          let _menhir_stack = MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState067
      | IDENT _v_3 ->
          let _menhir_stack = MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState067
      | CHAR_LITERAL _v_4 ->
          let _menhir_stack = MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState067
      | AS | BAR | CARET | EMPTY_STR | EOF | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | QUESTION | RBRACKET | RPAREN | SLASH | STAR | TILDE | UNDERSCORE ->
          let (_endpos__1_, _1) = (_endpos, _v) in
          let _v = _menhir_action_093 _1 in
          _menhir_goto_char_set _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_057 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _1) = (_endpos, _v) in
      let _v = _menhir_action_100 _1 in
      _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
  
  and _menhir_run_058 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _1) = (_endpos, _v) in
      let _v = _menhir_action_099 _1 in
      _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
  
  and _menhir_run_059 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DASH ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _v_2 ->
              let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_1, _startpos__2_, _endpos__3_, _3) = (_v, _startpos_0, _endpos_4, _v_2) in
              let _v = _menhir_action_102 _1 _3 _endpos__3_ _startpos__2_ in
              _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | INT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RBRACKET | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let (_endpos__1_, _1) = (_endpos, _v) in
          let _v = _menhir_action_101 _1 in
          _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_062 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DASH ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | CHAR_LITERAL _v_2 ->
              let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_1, _endpos__3_, _3) = (_v, _endpos_4, _v_2) in
              let _v = _menhir_action_096 _1 _3 in
              _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _v _menhir_s _tok
          | AS | BAR | CARET | EMPTY_STR | EOF | IDENT _ | INT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RBRACKET | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
              let (_endpos__2_, _startpos__2_) = (_endpos_1, _startpos_0) in
              let _v = _menhir_action_097 _endpos__2_ _startpos__2_ in
              _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | INT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RBRACKET | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let (_endpos__1_, _1) = (_endpos, _v) in
          let _v = _menhir_action_095 _1 in
          _menhir_goto_char_set_item _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_char_set : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState067 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState065 ->
          _menhir_run_069 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState053 ->
          _menhir_run_071 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_068 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_char_set_item -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_char_set_item (_menhir_stack, _menhir_s, _1, _) = _menhir_stack in
      let (_endpos__2_, _2) = (_endpos, _v) in
      let _v = _menhir_action_094 _1 _2 in
      _menhir_goto_char_set _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _v _menhir_s _tok
  
  and _menhir_run_069 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LBRACKET, ttv_result) _menhir_cell1_CARET -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_CARET (_menhir_stack, _, _, _) = _menhir_stack in
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_3, _endpos__4_) = (_v, _endpos_0) in
          let _v = _menhir_action_031 _3 _endpos__4_ _startpos__1_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_071 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_LBRACKET -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACKET ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_2, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_030 _2 _endpos__3_ _startpos__1_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let MenhirCell1_LBRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos__2_ = _endpos in
          let _v = _menhir_action_034 _endpos__2_ _startpos__1_ in
          _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_112 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_024 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_113 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_022 _1 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_114 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_026 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_115 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_006 _endpos__1_ _startpos__1_ in
      _menhir_goto_alt_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_alt_expr : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState117 ->
          _menhir_run_136 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState000 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState008 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState181 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState183 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState194 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_136 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_seq_expr _menhir_cell0_BAR -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_BAR (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _1, _startpos__1_, _) = _menhir_stack in
      let (_endpos__3_, _3) = (_endpos, _v) in
      let _v = _menhir_action_004 _1 _3 _endpos__3_ _startpos__1_ in
      _menhir_goto_alt_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_173 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PIPE ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MOD_IDENT _v_2 ->
              let _menhir_stack = MenhirCell1_alt_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_PIPE (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState174
          | IDENT _v_3 ->
              let _menhir_stack = MenhirCell1_alt_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_PIPE (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState174
          | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | LBRACE | LBRACKET | LPAREN | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
              let (_endpos__2_, _startpos__2_) = (_endpos_1, _startpos_0) in
              let _v = _menhir_action_116 _endpos__2_ _startpos__2_ in
              _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | AS | BAR | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let (_endpos__1_, _1) = (_endpos, _v) in
          let _v = _menhir_action_114 _1 in
          _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_118 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_028 _1 _endpos__1_ _startpos__1_ in
      _menhir_goto_basic_atom _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_seq_expr : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState000 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState008 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState117 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState181 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState183 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState194 ->
          _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState134 ->
          _menhir_run_135 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_116 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | BAR ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | STRING_LITERAL _v_2 ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState117
          | STAR ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | QUESTION ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | PREDEFINED_CLASS _v_3 ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState117
          | PLUS ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | MOD_IDENT _v_4 ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState117
          | LPAREN ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | LBRACKET ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | IDENT _v_5 ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState117
          | EMPTY_STR ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | CHAR_LITERAL _v_6 ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState117
          | CARET ->
              let _menhir_stack = MenhirCell1_seq_expr (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_BAR (_menhir_stack, _startpos_0, _endpos_1) in
              _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState117
          | AS | BAR | EOF | LBRACE | PIPE | RPAREN | SLASH | TILDE ->
              let (_startpos__1_, _endpos__2_, _startpos__2_) = (_startpos, _endpos_1, _startpos_0) in
              let _v = _menhir_action_005 _endpos__2_ _startpos__2_ in
              _menhir_goto_alt_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | AS | CARET | CHAR_LITERAL _ | EMPTY_STR | EOF | IDENT _ | LBRACE | LBRACKET | LPAREN | MOD_IDENT _ | PIPE | PLUS | PREDEFINED_CLASS _ | QUESTION | RPAREN | SLASH | STAR | STRING_LITERAL _ | TILDE | UNDERSCORE ->
          let (_endpos__1_, _startpos__1_, _1) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_003 _1 in
          _menhir_goto_alt_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_135 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_atom_expr -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_atom_expr (_menhir_stack, _menhir_s, _1, _startpos__1_, _) = _menhir_stack in
      let (_endpos__2_, _2) = (_endpos, _v) in
      let _v = _menhir_action_121 _1 _2 _endpos__2_ _startpos__1_ in
      _menhir_goto_seq_expr _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main_let_expr =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | STRING_LITERAL _v ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState000
      | STAR ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | QUESTION ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | PREDEFINED_CLASS _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState000
      | PLUS ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | MOD_IDENT _v ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState000
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | LBRACKET ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | IDENT _v ->
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState000
      | EMPTY_STR ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | CHAR_LITERAL _v ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState000
      | CARET ->
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | BAR ->
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | EOF ->
          let _v =
            let _endpos__0_ = _endpos in
            _menhir_action_119 _endpos__0_
          in
          _menhir_run_178 _menhir_stack _v _tok
      | _ ->
          _eRR ()
  
  let _menhir_error_goto_main_match_case : type  ttv_stack. ttv_stack -> _ -> _menhir_box_main_match_case =
    fun _menhir_stack _v ->
      MenhirBox_main_match_case _v
  
  let _menhir_run_181 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_main_match_case =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNDERSCORE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | STRING_LITERAL _v ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState181
      | STAR ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | SLASH ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | UNDERSCORE ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | STRING_LITERAL _v ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState183
          | STAR ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | QUESTION ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | PREDEFINED_CLASS _v ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState183
          | PLUS ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | MOD_IDENT _v ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState183
          | LPAREN ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | LBRACKET ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | IDENT _v ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState183
          | EMPTY_STR ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | CHAR_LITERAL _v ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState183
          | CARET ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | BAR ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | EOF | SLASH ->
              let _menhir_stack = MenhirCell1_SLASH (_menhir_stack, MenhirState181, _startpos) in
              let _v =
                let _endpos__0_ = _endpos in
                _menhir_action_119 _endpos__0_
              in
              _menhir_run_185 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | _ ->
              let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_endpos__2_, _startpos__2_) = (_endpos, _startpos_0) in
              let _v = _menhir_action_110 _endpos__2_ _startpos__2_ in
              _menhir_error_goto_main_match_case _menhir_stack _v)
      | QUESTION ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | PREDEFINED_CLASS _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState181
      | PLUS ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | MOD_IDENT _v ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState181
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | LBRACKET ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | IDENT _v ->
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState181
      | EMPTY_STR ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | CHAR_LITERAL _v ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState181
      | CARET ->
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | BAR ->
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState181
      | EOF ->
          let _v =
            let _endpos__0_ = _endpos in
            _menhir_action_119 _endpos__0_
          in
          _menhir_run_191 _menhir_stack _v _tok
      | _ ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
          let _v = _menhir_action_111 _endpos__1_ _startpos__1_ in
          _menhir_error_goto_main_match_case _menhir_stack _v
  
  let _menhir_run_194 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_pattern =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState194 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
      | STRING_LITERAL _v ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | STAR ->
          _menhir_run_003 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | QUESTION ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PREDEFINED_CLASS _v ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | PLUS ->
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | MOD_IDENT _v ->
          _menhir_run_007 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LBRACKET ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IDENT _v ->
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | EMPTY_STR ->
          _menhir_run_112 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | CHAR_LITERAL _v ->
          _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | CARET ->
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BAR ->
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
end

let pattern =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_pattern v = _menhir_run_194 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let main_match_case =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_main_match_case v = _menhir_run_181 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let main_let_expr =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_main_let_expr v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v