Source file parser.ml

module MenhirBasics = struct
  
  exception Error = Parsing.Parse_error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | VAR of (
# 24 "parser.mly"
       (string)
# 15 "parser.ml"
  )
    | UNK
    | UNCOV
    | SEQ of (
# 23 "parser.mly"
       (int)
# 22 "parser.ml"
  )
    | SC
    | RP
    | RANGLE
    | PLUS
    | PIPE
    | NEQ
    | LP
    | LANGLE
    | LAB of (
# 23 "parser.mly"
       (int)
# 35 "parser.ml"
  )
    | ID of (
# 23 "parser.mly"
       (int)
# 40 "parser.ml"
  )
    | EQ
    | EOF
    | ENV of (
# 24 "parser.mly"
       (string)
# 47 "parser.ml"
  )
    | DOT
    | DASH
    | COV
    | COMMA
    | AND
  
end

include MenhirBasics

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

  | MenhirState05 : (('s, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_state
    (** State 05.
        Stack shape : id.
        Start symbol: hyplist_root. *)

  | MenhirState07 : (('s, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_state
    (** State 07.
        Stack shape : LP.
        Start symbol: hyplist_root. *)

  | MenhirState08 : (('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_state
    (** State 08.
        Stack shape : LANGLE.
        Start symbol: hyplist_root. *)

  | MenhirState10 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 10.
        Stack shape : LANGLE hyp.
        Start symbol: hyplist_root. *)

  | MenhirState11 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS, _menhir_box_hyplist_root) _menhir_state
    (** State 11.
        Stack shape : hyp PLUS.
        Start symbol: hyplist_root. *)

  | MenhirState12 : (((('s, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 12.
        Stack shape : hyp PLUS hyp.
        Start symbol: hyplist_root. *)

  | MenhirState13 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_DOT, _menhir_box_hyplist_root) _menhir_state
    (** State 13.
        Stack shape : hyp DOT.
        Start symbol: hyplist_root. *)

  | MenhirState16 : (((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_state
    (** State 16.
        Stack shape : LANGLE hyp PIPE.
        Start symbol: hyplist_root. *)

  | MenhirState21 : ((((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_var, _menhir_box_hyplist_root) _menhir_state
    (** State 21.
        Stack shape : LANGLE hyp PIPE var.
        Start symbol: hyplist_root. *)

  | MenhirState23 : ((((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_var, _menhir_box_hyplist_root) _menhir_state
    (** State 23.
        Stack shape : LANGLE hyp PIPE var.
        Start symbol: hyplist_root. *)

  | MenhirState29 : ((((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq, _menhir_box_hyplist_root) _menhir_state
    (** State 29.
        Stack shape : LANGLE hyp PIPE boolEq.
        Start symbol: hyplist_root. *)

  | MenhirState31 : (((((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq, _menhir_box_hyplist_root) _menhir_cell1_var, _menhir_box_hyplist_root) _menhir_state
    (** State 31.
        Stack shape : LANGLE hyp PIPE boolEq var.
        Start symbol: hyplist_root. *)

  | MenhirState33 : (((((('s, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq, _menhir_box_hyplist_root) _menhir_cell1_var, _menhir_box_hyplist_root) _menhir_state
    (** State 33.
        Stack shape : LANGLE hyp PIPE boolEq var.
        Start symbol: hyplist_root. *)

  | MenhirState35 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 35.
        Stack shape : LP hyp.
        Start symbol: hyplist_root. *)

  | MenhirState36 : (((('s, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS, _menhir_box_hyplist_root) _menhir_state
    (** State 36.
        Stack shape : LP hyp PLUS.
        Start symbol: hyplist_root. *)

  | MenhirState37 : ((((('s, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 37.
        Stack shape : LP hyp PLUS hyp.
        Start symbol: hyplist_root. *)

  | MenhirState39 : (((('s, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_DOT, _menhir_box_hyplist_root) _menhir_state
    (** State 39.
        Stack shape : LP hyp DOT.
        Start symbol: hyplist_root. *)

  | MenhirState42 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 42.
        Stack shape : id hyp.
        Start symbol: hyplist_root. *)

  | MenhirState56 : (('s, _menhir_box_hyplist_root) _menhir_cell1_hyplist, _menhir_box_hyplist_root) _menhir_state
    (** State 56.
        Stack shape : hyplist.
        Start symbol: hyplist_root. *)

  | MenhirState58 : ((('s, _menhir_box_hyplist_root) _menhir_cell1_hyplist, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_state
    (** State 58.
        Stack shape : hyplist id.
        Start symbol: hyplist_root. *)

  | MenhirState59 : (((('s, _menhir_box_hyplist_root) _menhir_cell1_hyplist, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_state
    (** State 59.
        Stack shape : hyplist id hyp.
        Start symbol: hyplist_root. *)


and ('s, 'r) _menhir_cell1_boolEq = 
  | MenhirCell1_boolEq of 's * ('s, 'r) _menhir_state * ((string * string * string) list)

and ('s, 'r) _menhir_cell1_hyp = 
  | MenhirCell1_hyp of 's * ('s, 'r) _menhir_state * (Hhelpers.node)

and ('s, 'r) _menhir_cell1_hyplist = 
  | MenhirCell1_hyplist of 's * ('s, 'r) _menhir_state * (Hhelpers.node list)

and ('s, 'r) _menhir_cell1_id = 
  | MenhirCell1_id of 's * ('s, 'r) _menhir_state * (int)

and ('s, 'r) _menhir_cell1_var = 
  | MenhirCell1_var of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_DOT = 
  | MenhirCell1_DOT of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LANGLE = 
  | MenhirCell1_LANGLE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_LP = 
  | MenhirCell1_LP of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_PIPE = 
  | MenhirCell1_PIPE of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_PLUS = 
  | MenhirCell1_PLUS of 's * ('s, 'r) _menhir_state

and _menhir_box_hyplist_root = 
  | MenhirBox_hyplist_root of (Hhelpers.node list) [@@unboxed]

let _menhir_action_01 =
  fun _1 _3 ->
    (* boolEq -> var EQ var *)
    (
# 94 "parser.mly"
                ( [(_1,"=",_3)] )
# 210 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_02 =
  fun _1 _3 ->
    (* boolEq -> var NEQ var *)
    (
# 95 "parser.mly"
                 ( [(_1,"!",_3)] )
# 219 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_03 =
  fun _1 _3 _5 ->
    (* boolEq -> boolEq AND var EQ var *)
    (
# 96 "parser.mly"
                          ( _1 @ [(_3,"=",_5)] )
# 228 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_04 =
  fun _1 _3 _5 ->
    (* boolEq -> boolEq AND var NEQ var *)
    (
# 97 "parser.mly"
                           ( _1 @ [(_3,"!",_5)] )
# 237 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_05 =
  fun () ->
    (* cond -> *)
    (
# 89 "parser.mly"
    ( [] )
# 246 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_06 =
  fun _1 ->
    (* cond -> boolEq *)
    (
# 90 "parser.mly"
           ( _1 )
# 255 "parser.ml"
     : ((string * string * string) list))

let _menhir_action_07 =
  fun _1 ->
    (* hyp -> LAB *)
    (
# 79 "parser.mly"
         ( Hhelpers.createDnfFromLabel _1 )
# 264 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_08 =
  fun _1 ->
    (* hyp -> SEQ *)
    (
# 80 "parser.mly"
         ( Hhelpers.createDnfFromSequence _1 )
# 273 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_09 =
  fun _2 _5 ->
    (* hyp -> LANGLE hyp PIPE SC cond SC RANGLE *)
    (
# 81 "parser.mly"
                                       ( Hhelpers.createDnfFromGuard _2 _5 )
# 282 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_10 =
  fun _1 _3 ->
    (* hyp -> hyp DOT hyp *)
    (
# 82 "parser.mly"
                ( Hhelpers.createDnfFromConjunction _1 _3 )
# 291 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_11 =
  fun _2 _4 ->
    (* hyp -> LP hyp DOT hyp RP *)
    (
# 83 "parser.mly"
                      ( Hhelpers.createDnfFromConjunction _2 _4 )
# 300 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_12 =
  fun _1 _3 ->
    (* hyp -> hyp PLUS hyp *)
    (
# 84 "parser.mly"
                 ( Hhelpers.createDnfFromDisjunction _1 _3 )
# 309 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_13 =
  fun _2 _4 ->
    (* hyp -> LP hyp PLUS hyp RP *)
    (
# 85 "parser.mly"
                       ( Hhelpers.createDnfFromDisjunction _2 _4 )
# 318 "parser.ml"
     : (Hhelpers.node))

let _menhir_action_14 =
  fun _1 _2 _3 _4 ->
    (* hyplist -> hyplist id hyp status COMMA *)
    (
# 61 "parser.mly"
                                ( (List.append _1 [(Hhelpers.annotateHLabel _2 _3 _4)]) )
# 327 "parser.ml"
     : (Hhelpers.node list))

let _menhir_action_15 =
  fun _1 _2 _3 ->
    (* hyplist -> id hyp status COMMA *)
    (
# 62 "parser.mly"
                        ( [(Hhelpers.annotateHLabel _1 _2 _3)] )
# 336 "parser.ml"
     : (Hhelpers.node list))

let _menhir_action_16 =
  fun () ->
    (* hyplist -> COMMA *)
    (
# 63 "parser.mly"
          ( [] )
# 345 "parser.ml"
     : (Hhelpers.node list))

let _menhir_action_17 =
  fun () ->
    (* hyplist_root -> EOF *)
    (
# 56 "parser.mly"
              ( [] )
# 354 "parser.ml"
     : (Hhelpers.node list))

let _menhir_action_18 =
  fun _1 ->
    (* hyplist_root -> hyplist EOF *)
    (
# 57 "parser.mly"
                ( _1 )
# 363 "parser.ml"
     : (Hhelpers.node list))

let _menhir_action_19 =
  fun () ->
    (* id -> *)
    (
# 67 "parser.mly"
    ( -1 )
# 372 "parser.ml"
     : (int))

let _menhir_action_20 =
  fun _1 ->
    (* id -> ID RP *)
    (
# 68 "parser.mly"
          ( _1 )
# 381 "parser.ml"
     : (int))

let _menhir_action_21 =
  fun () ->
    (* status -> *)
    (
# 72 "parser.mly"
    ( Hhelpers.Unknown "" )
# 390 "parser.ml"
     : (Hhelpers.status))

let _menhir_action_22 =
  fun _4 ->
    (* status -> DASH COV DASH ENV *)
    (
# 73 "parser.mly"
                      ( Hhelpers.Covered _4 )
# 399 "parser.ml"
     : (Hhelpers.status))

let _menhir_action_23 =
  fun _4 ->
    (* status -> DASH UNK DASH ENV *)
    (
# 74 "parser.mly"
                      ( Hhelpers.Unknown _4 )
# 408 "parser.ml"
     : (Hhelpers.status))

let _menhir_action_24 =
  fun _4 ->
    (* status -> DASH UNCOV DASH ENV *)
    (
# 75 "parser.mly"
                        ( Hhelpers.Uncoverable _4 )
# 417 "parser.ml"
     : (Hhelpers.status))

let _menhir_action_25 =
  fun _1 ->
    (* var -> VAR *)
    (
# 101 "parser.mly"
         ( _1 )
# 426 "parser.ml"
     : (string))

let _menhir_action_26 =
  fun _1 ->
    (* var -> LAB *)
    (
# 102 "parser.mly"
         ( "l" ^ string_of_int _1 )
# 435 "parser.ml"
     : (string))

let _menhir_action_27 =
  fun _1 ->
    (* var -> SEQ *)
    (
# 103 "parser.mly"
         ( "s" ^ string_of_int _1 )
# 444 "parser.ml"
     : (string))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | AND ->
        "AND"
    | COMMA ->
        "COMMA"
    | COV ->
        "COV"
    | DASH ->
        "DASH"
    | DOT ->
        "DOT"
    | ENV _ ->
        "ENV"
    | EOF ->
        "EOF"
    | EQ ->
        "EQ"
    | ID _ ->
        "ID"
    | LAB _ ->
        "LAB"
    | LANGLE ->
        "LANGLE"
    | LP ->
        "LP"
    | NEQ ->
        "NEQ"
    | PIPE ->
        "PIPE"
    | PLUS ->
        "PLUS"
    | RANGLE ->
        "RANGLE"
    | RP ->
        "RP"
    | SC ->
        "SC"
    | SEQ _ ->
        "SEQ"
    | UNCOV ->
        "UNCOV"
    | UNK ->
        "UNK"
    | VAR _ ->
        "VAR"

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

include struct
  
  [@@@ocaml.warning "-4-37"]
  
  let _menhir_goto_hyplist_root : type  ttv_stack. ttv_stack -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _v ->
      (* State 55: *)
      (* Accepting *)
      MenhirBox_hyplist_root _v
  
  let rec _menhir_run_01 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 1: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RP ->
          (* Shifting (RP) to state 2 *)
          (* State 2: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          (* Reducing production id -> ID RP *)
          let _1 = _v in
          let _v = _menhir_action_20 _1 in
          _menhir_goto_id _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_goto_id : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState56 ->
          _menhir_run_58 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_58 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyplist as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 58: *)
      let _menhir_stack = MenhirCell1_id (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEQ _v_0 ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState58
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState58
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState58
      | LAB _v_1 ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState58
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_06 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 6: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      (* Reducing production hyp -> SEQ *)
      let _1 = _v in
      let _v = _menhir_action_08 _1 in
      _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_hyp : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState58 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState05 ->
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState39 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState36 ->
          _menhir_run_37 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState07 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState13 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState11 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState08 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_59 : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyplist, _menhir_box_hyplist_root) _menhir_cell1_id as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 59: *)
      let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          (* Shifting (PLUS) to state 11 *)
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | DOT ->
          (* Shifting (DOT) to state 13 *)
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | DASH ->
          (* Shifting (DASH) to state 43 *)
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | COMMA ->
          (* Reducing production status -> *)
          let _v_0 = _menhir_action_21 () in
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_11 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyp as 'stack) -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      (* State 11: *)
      let _menhir_stack = MenhirCell1_PLUS (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState11 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SEQ _v ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LAB _v ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_07 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      (* State 7: *)
      let _menhir_stack = MenhirCell1_LP (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState07 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SEQ _v ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LAB _v ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_08 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      (* State 8: *)
      let _menhir_stack = MenhirCell1_LANGLE (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState08 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SEQ _v ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LAB _v ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_09 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 9: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      (* Reducing production hyp -> LAB *)
      let _1 = _v in
      let _v = _menhir_action_07 _1 in
      _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_13 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyp as 'stack) -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      (* State 13: *)
      let _menhir_stack = MenhirCell1_DOT (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState13 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | SEQ _v ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | LAB _v ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_43 : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp as 'stack) -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      (* State 43: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | UNK ->
          (* Shifting (UNK) to state 44 *)
          (* State 44: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | DASH ->
              (* Shifting (DASH) to state 45 *)
              (* State 45: *)
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | ENV _v ->
                  (* Shifting (ENV) to state 46 *)
                  (* State 46: *)
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (* Reducing production status -> DASH UNK DASH ENV *)
                  let _4 = _v in
                  let _v = _menhir_action_23 _4 in
                  _menhir_goto_status _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  (* Initiating error handling *)
                  _eRR ())
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | UNCOV ->
          (* Shifting (UNCOV) to state 47 *)
          (* State 47: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | DASH ->
              (* Shifting (DASH) to state 48 *)
              (* State 48: *)
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | ENV _v ->
                  (* Shifting (ENV) to state 49 *)
                  (* State 49: *)
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (* Reducing production status -> DASH UNCOV DASH ENV *)
                  let _4 = _v in
                  let _v = _menhir_action_24 _4 in
                  _menhir_goto_status _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  (* Initiating error handling *)
                  _eRR ())
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | COV ->
          (* Shifting (COV) to state 50 *)
          (* State 50: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | DASH ->
              (* Shifting (DASH) to state 51 *)
              (* State 51: *)
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | ENV _v ->
                  (* Shifting (ENV) to state 52 *)
                  (* State 52: *)
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (* Reducing production status -> DASH COV DASH ENV *)
                  let _4 = _v in
                  let _v = _menhir_action_22 _4 in
                  _menhir_goto_status _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  (* Initiating error handling *)
                  _eRR ())
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_goto_status : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState59 ->
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState42 ->
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_60 : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyplist, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 60: *)
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          (* Shifting (COMMA) to state 61 *)
          (* State 61: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_hyp (_menhir_stack, _, _3) = _menhir_stack in
          let MenhirCell1_id (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_hyplist (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          (* Reducing production hyplist -> hyplist id hyp status COMMA *)
          let _4 = _v in
          let _v = _menhir_action_14 _1 _2 _3 _4 in
          _menhir_goto_hyplist _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_goto_hyplist : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 56: *)
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          let _menhir_stack = MenhirCell1_hyplist (_menhir_stack, _menhir_s, _v) in
          (* Shifting (ID) to state 1 *)
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState56
      | EOF ->
          (* Shifting (EOF) to state 57 *)
          (* State 57: *)
          (* Reducing production hyplist_root -> hyplist EOF *)
          let _1 = _v in
          let _v = _menhir_action_18 _1 in
          _menhir_goto_hyplist_root _menhir_stack _v
      | LAB _ | LANGLE | LP | SEQ _ ->
          let _menhir_stack = MenhirCell1_hyplist (_menhir_stack, _menhir_s, _v) in
          (* Reducing production id -> *)
          let _v_1 = _menhir_action_19 () in
          _menhir_run_58 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState56 _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_53 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_id, _menhir_box_hyplist_root) _menhir_cell1_hyp -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 53: *)
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          (* Shifting (COMMA) to state 54 *)
          (* State 54: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_hyp (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_id (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          (* Reducing production hyplist -> id hyp status COMMA *)
          let _3 = _v in
          let _v = _menhir_action_15 _1 _2 _3 in
          _menhir_goto_hyplist _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_42 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_id as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 42: *)
      let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          (* Shifting (PLUS) to state 11 *)
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState42
      | DOT ->
          (* Shifting (DOT) to state 13 *)
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState42
      | DASH ->
          (* Shifting (DASH) to state 43 *)
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState42
      | COMMA ->
          (* Reducing production status -> *)
          let _v_0 = _menhir_action_21 () in
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_40 : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_DOT -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 40: *)
      match (_tok : MenhirBasics.token) with
      | RP ->
          (* Shifting (RP) to state 41 *)
          (* State 41: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_DOT (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_LP (_menhir_stack, _menhir_s) = _menhir_stack in
          (* Reducing production hyp -> LP hyp DOT hyp RP *)
          let _4 = _v in
          let _v = _menhir_action_11 _2 _4 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | DOT | PLUS ->
          let MenhirCell1_DOT (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          (* Reducing production hyp -> hyp DOT hyp *)
          let _3 = _v in
          let _v = _menhir_action_10 _1 _3 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_37 : type  ttv_stack. ((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LP, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 37: *)
      match (_tok : MenhirBasics.token) with
      | RP ->
          (* Shifting (RP) to state 38 *)
          (* State 38: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_PLUS (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_LP (_menhir_stack, _menhir_s) = _menhir_stack in
          (* Reducing production hyp -> LP hyp PLUS hyp RP *)
          let _4 = _v in
          let _v = _menhir_action_13 _2 _4 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | DOT ->
          let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
          (* Shifting (DOT) to state 13 *)
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState37
      | PLUS ->
          let MenhirCell1_PLUS (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          (* Reducing production hyp -> hyp PLUS hyp *)
          let _3 = _v in
          let _v = _menhir_action_12 _1 _3 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_35 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LP as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 35: *)
      let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          (* Shifting (PLUS) to state 36 *)
          (* State 36: *)
          let _menhir_stack = MenhirCell1_PLUS (_menhir_stack, MenhirState35) in
          let _menhir_s = MenhirState36 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEQ _v ->
              (* Shifting (SEQ) to state 6 *)
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LP ->
              (* Shifting (LP) to state 7 *)
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LANGLE ->
              (* Shifting (LANGLE) to state 8 *)
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 9 *)
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | DOT ->
          (* Shifting (DOT) to state 39 *)
          (* State 39: *)
          let _menhir_stack = MenhirCell1_DOT (_menhir_stack, MenhirState35) in
          let _menhir_s = MenhirState39 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEQ _v ->
              (* Shifting (SEQ) to state 6 *)
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LP ->
              (* Shifting (LP) to state 7 *)
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LANGLE ->
              (* Shifting (LANGLE) to state 8 *)
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 9 *)
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_14 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_DOT -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 14: *)
      let MenhirCell1_DOT (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_hyp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      (* Reducing production hyp -> hyp DOT hyp *)
      let _3 = _v in
      let _v = _menhir_action_10 _1 _3 in
      _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_12 : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PLUS as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 12: *)
      match (_tok : MenhirBasics.token) with
      | DOT ->
          let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
          (* Shifting (DOT) to state 13 *)
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState12
      | COMMA | DASH | PIPE | PLUS | RP ->
          let MenhirCell1_PLUS (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _menhir_s, _1) = _menhir_stack in
          (* Reducing production hyp -> hyp PLUS hyp *)
          let _3 = _v in
          let _v = _menhir_action_12 _1 _3 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_10 : type  ttv_stack. ((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 10: *)
      let _menhir_stack = MenhirCell1_hyp (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          (* Shifting (PLUS) to state 11 *)
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState10
      | PIPE ->
          (* Shifting (PIPE) to state 15 *)
          (* State 15: *)
          let _menhir_stack = MenhirCell1_PIPE (_menhir_stack, MenhirState10) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SC ->
              (* Shifting (SC) to state 16 *)
              (* State 16: *)
              let _menhir_s = MenhirState16 in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | VAR _v ->
                  (* Shifting (VAR) to state 17 *)
                  _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | SEQ _v ->
                  (* Shifting (SEQ) to state 18 *)
                  _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | LAB _v ->
                  (* Shifting (LAB) to state 19 *)
                  _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | SC ->
                  (* Reducing production cond -> *)
                  let _v = _menhir_action_05 () in
                  _menhir_goto_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v
              | _ ->
                  (* Initiating error handling *)
                  _eRR ())
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | DOT ->
          (* Shifting (DOT) to state 13 *)
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState10
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_17 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 17: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      (* Reducing production var -> VAR *)
      let _1 = _v in
      let _v = _menhir_action_25 _1 in
      _menhir_goto_var _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_var : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState33 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState31 ->
          _menhir_run_32 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState29 ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState23 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState21 ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState16 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_34 : type  ttv_stack. (((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq, _menhir_box_hyplist_root) _menhir_cell1_var -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 34: *)
      let MenhirCell1_var (_menhir_stack, _, _3) = _menhir_stack in
      let MenhirCell1_boolEq (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      (* Reducing production boolEq -> boolEq AND var EQ var *)
      let _5 = _v in
      let _v = _menhir_action_03 _1 _3 _5 in
      _menhir_goto_boolEq _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_boolEq : type  ttv_stack. ((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 28: *)
      match (_tok : MenhirBasics.token) with
      | AND ->
          let _menhir_stack = MenhirCell1_boolEq (_menhir_stack, _menhir_s, _v) in
          (* Shifting (AND) to state 29 *)
          (* State 29: *)
          let _menhir_s = MenhirState29 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VAR _v ->
              (* Shifting (VAR) to state 17 *)
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SEQ _v ->
              (* Shifting (SEQ) to state 18 *)
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 19 *)
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | SC ->
          (* Reducing production cond -> boolEq *)
          let _1 = _v in
          let _v = _menhir_action_06 _1 in
          _menhir_goto_cond _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_18 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 18: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      (* Reducing production var -> SEQ *)
      let _1 = _v in
      let _v = _menhir_action_27 _1 in
      _menhir_goto_var _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_19 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      (* State 19: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      (* Reducing production var -> LAB *)
      let _1 = _v in
      let _v = _menhir_action_26 _1 in
      _menhir_goto_var _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_cond : type  ttv_stack. (((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      (* State 25: *)
      (* The current token is SC. *)
      (* Shifting (SC) to state 26 *)
      (* State 26: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | RANGLE ->
          (* Shifting (RANGLE) to state 27 *)
          (* State 27: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_PIPE (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_hyp (_menhir_stack, _, _2) = _menhir_stack in
          let MenhirCell1_LANGLE (_menhir_stack, _menhir_s) = _menhir_stack in
          (* Reducing production hyp -> LANGLE hyp PIPE SC cond SC RANGLE *)
          let _5 = _v in
          let _v = _menhir_action_09 _2 _5 in
          _menhir_goto_hyp _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_32 : type  ttv_stack. (((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq, _menhir_box_hyplist_root) _menhir_cell1_var -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 32: *)
      let MenhirCell1_var (_menhir_stack, _, _3) = _menhir_stack in
      let MenhirCell1_boolEq (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      (* Reducing production boolEq -> boolEq AND var NEQ var *)
      let _5 = _v in
      let _v = _menhir_action_04 _1 _3 _5 in
      _menhir_goto_boolEq _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_30 : type  ttv_stack. (((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_boolEq as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 30: *)
      let _menhir_stack = MenhirCell1_var (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | NEQ ->
          (* Shifting (NEQ) to state 31 *)
          (* State 31: *)
          let _menhir_s = MenhirState31 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VAR _v ->
              (* Shifting (VAR) to state 17 *)
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SEQ _v ->
              (* Shifting (SEQ) to state 18 *)
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 19 *)
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | EQ ->
          (* Shifting (EQ) to state 33 *)
          (* State 33: *)
          let _menhir_s = MenhirState33 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VAR _v ->
              (* Shifting (VAR) to state 17 *)
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SEQ _v ->
              (* Shifting (SEQ) to state 18 *)
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 19 *)
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_24 : type  ttv_stack. ((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_var -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 24: *)
      let MenhirCell1_var (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      (* Reducing production boolEq -> var EQ var *)
      let _3 = _v in
      let _v = _menhir_action_01 _1 _3 in
      _menhir_goto_boolEq _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_22 : type  ttv_stack. ((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE, _menhir_box_hyplist_root) _menhir_cell1_var -> _ -> _ -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      (* State 22: *)
      let MenhirCell1_var (_menhir_stack, _menhir_s, _1) = _menhir_stack in
      (* Reducing production boolEq -> var NEQ var *)
      let _3 = _v in
      let _v = _menhir_action_02 _1 _3 in
      _menhir_goto_boolEq _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_20 : type  ttv_stack. ((((ttv_stack, _menhir_box_hyplist_root) _menhir_cell1_LANGLE, _menhir_box_hyplist_root) _menhir_cell1_hyp, _menhir_box_hyplist_root) _menhir_cell1_PIPE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 20: *)
      let _menhir_stack = MenhirCell1_var (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | NEQ ->
          (* Shifting (NEQ) to state 21 *)
          (* State 21: *)
          let _menhir_s = MenhirState21 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VAR _v ->
              (* Shifting (VAR) to state 17 *)
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SEQ _v ->
              (* Shifting (SEQ) to state 18 *)
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 19 *)
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | EQ ->
          (* Shifting (EQ) to state 23 *)
          (* State 23: *)
          let _menhir_s = MenhirState23 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VAR _v ->
              (* Shifting (VAR) to state 17 *)
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SEQ _v ->
              (* Shifting (SEQ) to state 18 *)
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LAB _v ->
              (* Shifting (LAB) to state 19 *)
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              (* Initiating error handling *)
              _eRR ())
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  and _menhir_run_05 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_hyplist_root) _menhir_state -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      (* State 5: *)
      let _menhir_stack = MenhirCell1_id (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEQ _v_0 ->
          (* Shifting (SEQ) to state 6 *)
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState05
      | LP ->
          (* Shifting (LP) to state 7 *)
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState05
      | LANGLE ->
          (* Shifting (LANGLE) to state 8 *)
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState05
      | LAB _v_1 ->
          (* Shifting (LAB) to state 9 *)
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState05
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_hyplist_root =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      (* State 0: *)
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          (* Shifting (ID) to state 1 *)
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState00
      | EOF ->
          (* Shifting (EOF) to state 3 *)
          (* State 3: *)
          (* Reducing production hyplist_root -> EOF *)
          let _v = _menhir_action_17 () in
          _menhir_goto_hyplist_root _menhir_stack _v
      | COMMA ->
          (* Shifting (COMMA) to state 4 *)
          (* State 4: *)
          let _tok = _menhir_lexer _menhir_lexbuf in
          (* Reducing production hyplist -> COMMA *)
          let _menhir_s = MenhirState00 in
          let _v = _menhir_action_16 () in
          _menhir_goto_hyplist _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | LAB _ | LANGLE | LP | SEQ _ ->
          (* Reducing production id -> *)
          let _v = _menhir_action_19 () in
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState00 _tok
      | _ ->
          (* Initiating error handling *)
          _eRR ()
  
end

let hyplist_root =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_hyplist_root v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v