Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | SYMBOL of (
# 24 "lib/parser.mly"
       (Symbol.t)
# 15 "lib/parser.ml"
  )
    | STRING of (
# 21 "lib/parser.mly"
       (string)
# 20 "lib/parser.ml"
  )
    | SEMICOLON
    | RPAREN
    | RBRACE
    | RARROW
    | MATCH
    | LPAREN
    | LET
    | LBRACE
    | INT of (
# 20 "lib/parser.mly"
       (Checked_oint.generic)
# 33 "lib/parser.ml"
  )
    | EXTRACT
    | EOF
    | DEFINE
    | COMMENT of (
# 23 "lib/parser.mly"
       (string)
# 41 "lib/parser.ml"
  )
    | COMMA
    | CHAR of (
# 22 "lib/parser.mly"
       (char)
# 47 "lib/parser.ml"
  )
  
end

include MenhirBasics

# 4 "lib/parser.mly"
  
[@@@coverage exclude_file]

# 58 "lib/parser.ml"

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

  | MenhirState01 : (('s, _menhir_box_program) _menhir_cell1_EXTRACT, _menhir_box_program) _menhir_state
    (** State 01.
        Stack shape : EXTRACT.
        Start symbol: program. *)

  | MenhirState04 : (('s, _menhir_box_program) _menhir_cell1_COMMENT, _menhir_box_program) _menhir_state
    (** State 04.
        Stack shape : COMMENT.
        Start symbol: program. *)

  | MenhirState08 : (('s, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL, _menhir_box_program) _menhir_state
    (** State 08.
        Stack shape : def_attr_list SYMBOL.
        Start symbol: program. *)

  | MenhirState10 : (('s, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_state
    (** State 10.
        Stack shape : SYMBOL.
        Start symbol: program. *)

  | MenhirState15 : ((('s, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL, _menhir_box_program) _menhir_cell1_loption_separated_nonempty_list_COMMA_SYMBOL__, _menhir_box_program) _menhir_state
    (** State 15.
        Stack shape : def_attr_list SYMBOL loption(separated_nonempty_list(COMMA,SYMBOL)).
        Start symbol: program. *)

  | MenhirState17 : (('s, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_state
    (** State 17.
        Stack shape : SYMBOL.
        Start symbol: program. *)

  | MenhirState19 : (('s, _menhir_box_program) _menhir_cell1_MATCH, _menhir_box_program) _menhir_state
    (** State 19.
        Stack shape : MATCH.
        Start symbol: program. *)

  | MenhirState20 : (('s, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_state
    (** State 20.
        Stack shape : LET.
        Start symbol: program. *)

  | MenhirState22 : (('s, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_state
    (** State 22.
        Stack shape : SYMBOL.
        Start symbol: program. *)

  | MenhirState25 : ((('s, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_state
    (** State 25.
        Stack shape : LET SYMBOL.
        Start symbol: program. *)

  | MenhirState27 : (('s, _menhir_box_program) _menhir_cell1_COMMENT, _menhir_box_program) _menhir_state
    (** State 27.
        Stack shape : COMMENT.
        Start symbol: program. *)

  | MenhirState32 : (((('s, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_cell1_term, _menhir_box_program) _menhir_state
    (** State 32.
        Stack shape : LET SYMBOL term.
        Start symbol: program. *)

  | MenhirState35 : ((('s, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_pattern, _menhir_box_program) _menhir_state
    (** State 35.
        Stack shape : LET pattern.
        Start symbol: program. *)

  | MenhirState37 : (((('s, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_pattern, _menhir_box_program) _menhir_cell1_term, _menhir_box_program) _menhir_state
    (** State 37.
        Stack shape : LET pattern term.
        Start symbol: program. *)

  | MenhirState40 : ((('s, _menhir_box_program) _menhir_cell1_MATCH, _menhir_box_program) _menhir_cell1_term, _menhir_box_program) _menhir_state
    (** State 40.
        Stack shape : MATCH term.
        Start symbol: program. *)

  | MenhirState45 : (('s, _menhir_box_program) _menhir_cell1_pattern, _menhir_box_program) _menhir_state
    (** State 45.
        Stack shape : pattern.
        Start symbol: program. *)

  | MenhirState48 : (('s, _menhir_box_program) _menhir_cell1_match_case, _menhir_box_program) _menhir_state
    (** State 48.
        Stack shape : match_case.
        Start symbol: program. *)

  | MenhirState51 : (('s, _menhir_box_program) _menhir_cell1_term, _menhir_box_program) _menhir_state
    (** State 51.
        Stack shape : term.
        Start symbol: program. *)

  | MenhirState57 : (((('s, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL, _menhir_box_program) _menhir_cell1_loption_separated_nonempty_list_COMMA_SYMBOL__, _menhir_box_program) _menhir_cell1_term, _menhir_box_program) _menhir_state
    (** State 57.
        Stack shape : def_attr_list SYMBOL loption(separated_nonempty_list(COMMA,SYMBOL)) term.
        Start symbol: program. *)


and ('s, 'r) _menhir_cell1_def_attr_list = 
  | MenhirCell1_def_attr_list of 's * ('s, 'r) _menhir_state * (Raw_program.attr_list)

and ('s, 'r) _menhir_cell1_loption_separated_nonempty_list_COMMA_SYMBOL__ = 
  | MenhirCell1_loption_separated_nonempty_list_COMMA_SYMBOL__ of 's * ('s, 'r) _menhir_state * (Symbol.t list)

and ('s, 'r) _menhir_cell1_match_case = 
  | MenhirCell1_match_case of 's * ('s, 'r) _menhir_state * (Raw_term.match_case)

and ('s, 'r) _menhir_cell1_pattern = 
  | MenhirCell1_pattern of 's * ('s, 'r) _menhir_state * (Raw_term.pattern)

and ('s, 'r) _menhir_cell1_term = 
  | MenhirCell1_term of 's * ('s, 'r) _menhir_state * (Raw_term.t)

and ('s, 'r) _menhir_cell1_COMMENT = 
  | MenhirCell1_COMMENT of 's * ('s, 'r) _menhir_state * (
# 23 "lib/parser.mly"
       (string)
# 181 "lib/parser.ml"
)

and ('s, 'r) _menhir_cell1_EXTRACT = 
  | MenhirCell1_EXTRACT of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LET = 
  | MenhirCell1_LET of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MATCH = 
  | MenhirCell1_MATCH of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_SYMBOL = 
  | MenhirCell1_SYMBOL of 's * ('s, 'r) _menhir_state * (
# 24 "lib/parser.mly"
       (Symbol.t)
# 197 "lib/parser.ml"
)

and 's _menhir_cell0_SYMBOL = 
  | MenhirCell0_SYMBOL of 's * (
# 24 "lib/parser.mly"
       (Symbol.t)
# 204 "lib/parser.ml"
)

and _menhir_box_program = 
  | MenhirBox_program of (Raw_program.t) [@@unboxed]

let _menhir_action_01 =
  fun x ->
    (
# 75 "lib/parser.mly"
              ( Const.Int x )
# 215 "lib/parser.ml"
     : (Const.t))

let _menhir_action_02 =
  fun s ->
    (
# 76 "lib/parser.mly"
                 ( Const.String s )
# 223 "lib/parser.ml"
     : (Const.t))

let _menhir_action_03 =
  fun c ->
    (
# 77 "lib/parser.mly"
               (
        let open Checked_oint in
        let x = U8.of_int_exn (int_of_char c) in
        Const.Int (U8 x)
    )
# 235 "lib/parser.ml"
     : (Const.t))

let _menhir_action_04 =
  fun rest ->
    (
# 47 "lib/parser.mly"
                                    ( `Extract :: rest )
# 243 "lib/parser.ml"
     : (Raw_program.attr_list))

let _menhir_action_05 =
  fun () ->
    (
# 48 "lib/parser.mly"
      ( [] )
# 251 "lib/parser.ml"
     : (Raw_program.attr_list))

let _menhir_action_06 =
  fun attrs body f rest xs ->
    let params = 
# 241 "<standard.mly>"
    ( xs )
# 259 "lib/parser.ml"
     in
    (
# 38 "lib/parser.mly"
                             (
        (attrs, f, params, body) :: rest
    )
# 266 "lib/parser.ml"
     : (Raw_program.t))

let _menhir_action_07 =
  fun rest ->
    (
# 42 "lib/parser.mly"
                                    ( rest )
# 274 "lib/parser.ml"
     : (Raw_program.t))

let _menhir_action_08 =
  fun () ->
    (
# 44 "lib/parser.mly"
          ( [] )
# 282 "lib/parser.ml"
     : (Raw_program.t))

let _menhir_action_09 =
  fun () ->
    (
# 145 "<standard.mly>"
    ( [] )
# 290 "lib/parser.ml"
     : (Symbol.t list))

let _menhir_action_10 =
  fun x ->
    (
# 148 "<standard.mly>"
    ( x )
# 298 "lib/parser.ml"
     : (Symbol.t list))

let _menhir_action_11 =
  fun () ->
    (
# 145 "<standard.mly>"
    ( [] )
# 306 "lib/parser.ml"
     : (Raw_term.t list))

let _menhir_action_12 =
  fun x ->
    (
# 148 "<standard.mly>"
    ( x )
# 314 "lib/parser.ml"
     : (Raw_term.t list))

let _menhir_action_13 =
  fun p t ->
    (
# 84 "lib/parser.mly"
                                    (
        p, t
    )
# 324 "lib/parser.ml"
     : (Raw_term.match_case))

let _menhir_action_14 =
  fun c xs ->
    let c_params = 
# 241 "<standard.mly>"
    ( xs )
# 332 "lib/parser.ml"
     in
    (
# 89 "lib/parser.mly"
                                                                           (
        c, c_params
    )
# 339 "lib/parser.ml"
     : (Raw_term.pattern))

let _menhir_action_15 =
  fun defs ->
    (
# 33 "lib/parser.mly"
                           ( defs )
# 347 "lib/parser.ml"
     : (Raw_program.t))

let _menhir_action_16 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 355 "lib/parser.ml"
     : (Symbol.t list))

let _menhir_action_17 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 363 "lib/parser.ml"
     : (Symbol.t list))

let _menhir_action_18 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 371 "lib/parser.ml"
     : (Raw_term.match_case list))

let _menhir_action_19 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 379 "lib/parser.ml"
     : (Raw_term.match_case list))

let _menhir_action_20 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 387 "lib/parser.ml"
     : (Raw_term.t list))

let _menhir_action_21 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 395 "lib/parser.ml"
     : (Raw_term.t list))

let _menhir_action_22 =
  fun x ->
    (
# 51 "lib/parser.mly"
                 ( Raw_term.Var x )
# 403 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_23 =
  fun const ->
    (
# 53 "lib/parser.mly"
                    ( Raw_term.Const const )
# 411 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_24 =
  fun op xs ->
    let args = 
# 241 "<standard.mly>"
    ( xs )
# 419 "lib/parser.ml"
     in
    (
# 55 "lib/parser.mly"
                                                                      (
        Raw_term.Call (op, args)
    )
# 426 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_25 =
  fun cases t ->
    (
# 60 "lib/parser.mly"
                                                                           (
        Raw_term.Match (t, cases)
    )
# 436 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_26 =
  fun t u x ->
    (
# 64 "lib/parser.mly"
                                                             (
        Raw_term.Let (x, t, u)
    )
# 446 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_27 =
  fun p t u ->
    (
# 68 "lib/parser.mly"
                                                              (
        Raw_term.Match (t, [ p, u ])
    )
# 456 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_action_28 =
  fun t ->
    (
# 72 "lib/parser.mly"
                        ( t )
# 464 "lib/parser.ml"
     : (Raw_term.t))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | CHAR _ ->
        "CHAR"
    | COMMA ->
        "COMMA"
    | COMMENT _ ->
        "COMMENT"
    | DEFINE ->
        "DEFINE"
    | EOF ->
        "EOF"
    | EXTRACT ->
        "EXTRACT"
    | INT _ ->
        "INT"
    | LBRACE ->
        "LBRACE"
    | LET ->
        "LET"
    | LPAREN ->
        "LPAREN"
    | MATCH ->
        "MATCH"
    | RARROW ->
        "RARROW"
    | RBRACE ->
        "RBRACE"
    | RPAREN ->
        "RPAREN"
    | SEMICOLON ->
        "SEMICOLON"
    | STRING _ ->
        "STRING"
    | SYMBOL _ ->
        "SYMBOL"

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_60 : type  ttv_stack. ttv_stack -> _ -> _menhir_box_program =
    fun _menhir_stack _v ->
      let defs = _v in
      let _v = _menhir_action_15 defs in
      MenhirBox_program _v
  
  let rec _menhir_goto_file_def_list : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState00 ->
          _menhir_run_60 _menhir_stack _v
      | MenhirState57 ->
          _menhir_run_58 _menhir_stack _v
      | MenhirState04 ->
          _menhir_run_05 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_58 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL, _menhir_box_program) _menhir_cell1_loption_separated_nonempty_list_COMMA_SYMBOL__, _menhir_box_program) _menhir_cell1_term -> _ -> _menhir_box_program =
    fun _menhir_stack _v ->
      let MenhirCell1_term (_menhir_stack, _, body) = _menhir_stack in
      let MenhirCell1_loption_separated_nonempty_list_COMMA_SYMBOL__ (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell0_SYMBOL (_menhir_stack, f) = _menhir_stack in
      let MenhirCell1_def_attr_list (_menhir_stack, _menhir_s, attrs) = _menhir_stack in
      let rest = _v in
      let _v = _menhir_action_06 attrs body f rest xs in
      _menhir_goto_file_def_list _menhir_stack _v _menhir_s
  
  and _menhir_run_05 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_COMMENT -> _ -> _menhir_box_program =
    fun _menhir_stack _v ->
      let MenhirCell1_COMMENT (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let rest = _v in
      let _v = _menhir_action_07 rest in
      _menhir_goto_file_def_list _menhir_stack _v _menhir_s
  
  let _menhir_run_03 : type  ttv_stack. ttv_stack -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_s ->
      let _v = _menhir_action_08 () in
      _menhir_goto_file_def_list _menhir_stack _v _menhir_s
  
  let rec _menhir_run_01 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_EXTRACT (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EXTRACT ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | SYMBOL _ ->
          let _v = _menhir_action_05 () in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_02 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_EXTRACT -> _ -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_EXTRACT (_menhir_stack, _menhir_s) = _menhir_stack in
      let rest = _v in
      let _v = _menhir_action_04 rest in
      _menhir_goto_def_attr_list _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_def_attr_list : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState00 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState57 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState04 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_06 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_def_attr_list (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SYMBOL _v_0 ->
          let _menhir_stack = MenhirCell0_SYMBOL (_menhir_stack, _v_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAREN ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SYMBOL _v_1 ->
                  _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState08
              | RPAREN ->
                  let _v_2 = _menhir_action_09 () in
                  _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState08
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_09 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState10 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | RPAREN ->
          let x = _v in
          let _v = _menhir_action_16 x in
          _menhir_goto_separated_nonempty_list_COMMA_SYMBOL_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_SYMBOL_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState22 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MenhirState08 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MenhirState10 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_12 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let x = _v in
      let _v = _menhir_action_10 x in
      _menhir_goto_loption_separated_nonempty_list_COMMA_SYMBOL__ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_loption_separated_nonempty_list_COMMA_SYMBOL__ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState22 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState08 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_23 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_SYMBOL -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, c) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_14 c xs in
      _menhir_goto_pattern _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_pattern : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState48 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState40 ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState20 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_44 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RARROW ->
          let _menhir_s = MenhirState45 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_16 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          let _menhir_stack = MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState17 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | RPAREN ->
              let _v = _menhir_action_11 () in
              _menhir_goto_loption_separated_nonempty_list_COMMA_term__ _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | COMMA | LBRACE | RBRACE | RPAREN | SEMICOLON ->
          let x = _v in
          let _v = _menhir_action_22 x in
          _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_18 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let s = _v in
      let _v = _menhir_action_02 s in
      _menhir_goto_const _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_const : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let const = _v in
      let _v = _menhir_action_23 const in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_term : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState15 ->
          _menhir_run_56 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState51 ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState17 ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState45 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState19 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState35 ->
          _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState32 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState25 ->
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState27 ->
          _menhir_run_29 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_56 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL, _menhir_box_program) _menhir_cell1_loption_separated_nonempty_list_COMMA_SYMBOL__ as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_term (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | EXTRACT ->
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState57
          | EOF ->
              _menhir_run_03 _menhir_stack MenhirState57
          | COMMENT _v_0 ->
              _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState57
          | SYMBOL _ ->
              let _v_1 = _menhir_action_05 () in
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState57 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_04 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_COMMENT (_menhir_stack, _menhir_s, _v) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EXTRACT ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState04
      | EOF ->
          _menhir_run_03 _menhir_stack MenhirState04
      | COMMENT _v_0 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState04
      | SYMBOL _ ->
          let _v_1 = _menhir_action_05 () in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState04 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_50 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_term (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState51 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | RPAREN ->
          let x = _v in
          let _v = _menhir_action_20 x in
          _menhir_goto_separated_nonempty_list_COMMA_term_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_19 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MATCH (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState19 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SYMBOL _v ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | STRING _v ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MATCH ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LET ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | INT _v ->
          _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | COMMENT _v ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | CHAR _v ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_20 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_LET (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState20 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SYMBOL _v ->
          let _menhir_stack = MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAREN ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer
          | DEFINE ->
              let _menhir_s = MenhirState25 in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SYMBOL _v ->
                  _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | STRING _v ->
                  _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | MATCH ->
                  _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | LET ->
                  _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | INT _v ->
                  _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | COMMENT _v ->
                  _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | CHAR _v ->
                  _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_22 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_SYMBOL -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SYMBOL _v ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState22
      | RPAREN ->
          let _v = _menhir_action_09 () in
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_26 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let x = _v in
      let _v = _menhir_action_01 x in
      _menhir_goto_const _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_27 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_COMMENT (_menhir_stack, _menhir_s, _v) in
      let _menhir_s = MenhirState27 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SYMBOL _v ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | STRING _v ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MATCH ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LET ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | INT _v ->
          _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | COMMENT _v ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | CHAR _v ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_28 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let c = _v in
      let _v = _menhir_action_03 c in
      _menhir_goto_const _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_separated_nonempty_list_COMMA_term_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState17 ->
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState51 ->
          _menhir_run_52 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_53 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_SYMBOL -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let x = _v in
      let _v = _menhir_action_12 x in
      _menhir_goto_loption_separated_nonempty_list_COMMA_term__ _menhir_stack _menhir_lexbuf _menhir_lexer _v
  
  and _menhir_goto_loption_separated_nonempty_list_COMMA_term__ : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_SYMBOL -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, op) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_24 op xs in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_52 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_term -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_term (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_21 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_term_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_46 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_pattern -> _ -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_pattern (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_13 p t in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_match_case (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState48 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | RBRACE ->
          let x = _v in
          let _v = _menhir_action_18 x in
          _menhir_goto_separated_nonempty_list_COMMA_match_case_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_41 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, _v) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_match_case_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState48 ->
          _menhir_run_49 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState40 ->
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_49 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_match_case -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_match_case (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_19 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_match_case_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_run_42 : type  ttv_stack. ((ttv_stack, _menhir_box_program) _menhir_cell1_MATCH, _menhir_box_program) _menhir_cell1_term -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_term (_menhir_stack, _, t) = _menhir_stack in
      let MenhirCell1_MATCH (_menhir_stack, _menhir_s) = _menhir_stack in
      let cases = _v in
      let _v = _menhir_action_25 cases t in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_39 : type  ttv_stack. ((ttv_stack, _menhir_box_program) _menhir_cell1_MATCH as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_term (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LBRACE ->
          let _menhir_s = MenhirState40 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_38 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_pattern, _menhir_box_program) _menhir_cell1_term -> _ -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_term (_menhir_stack, _, t) = _menhir_stack in
      let MenhirCell1_pattern (_menhir_stack, _, p) = _menhir_stack in
      let MenhirCell1_LET (_menhir_stack, _menhir_s) = _menhir_stack in
      let u = _v in
      let _v = _menhir_action_27 p t u in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_36 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_pattern as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_term (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_s = MenhirState37 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_33 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_SYMBOL, _menhir_box_program) _menhir_cell1_term -> _ -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_term (_menhir_stack, _, t) = _menhir_stack in
      let MenhirCell1_SYMBOL (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_LET (_menhir_stack, _menhir_s) = _menhir_stack in
      let u = _v in
      let _v = _menhir_action_26 t u x in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_31 : type  ttv_stack. (((ttv_stack, _menhir_box_program) _menhir_cell1_LET, _menhir_box_program) _menhir_cell1_SYMBOL as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_term (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_s = MenhirState32 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_29 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_COMMENT -> _ -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_COMMENT (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_28 t in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_34 : type  ttv_stack. ((ttv_stack, _menhir_box_program) _menhir_cell1_LET as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_pattern (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | DEFINE ->
          let _menhir_s = MenhirState35 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_13 : type  ttv_stack. ((ttv_stack, _menhir_box_program) _menhir_cell1_def_attr_list _menhir_cell0_SYMBOL as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_program) _menhir_state -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _menhir_stack = MenhirCell1_loption_separated_nonempty_list_COMMA_SYMBOL__ (_menhir_stack, _menhir_s, _v) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | DEFINE ->
          let _menhir_s = MenhirState15 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SYMBOL _v ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MATCH ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LET ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INT _v ->
              _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMENT _v ->
              _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | CHAR _v ->
              _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_11 : type  ttv_stack. (ttv_stack, _menhir_box_program) _menhir_cell1_SYMBOL -> _ -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_SYMBOL (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_17 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_SYMBOL_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_program =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EXTRACT ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState00
      | EOF ->
          _menhir_run_03 _menhir_stack MenhirState00
      | COMMENT _v ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState00
      | SYMBOL _ ->
          let _v = _menhir_action_05 () in
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState00 _tok
      | _ ->
          _eRR ()
  
end

let program =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_program v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v