Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | TRUE
    | STRING of 
# 15 "src/parser.mly"
       (string)
# 16 "src/parser.ml"
  
    | SEMI
    | RPAREN
    | RBRACE
    | RAW_STRING of 
# 16 "src/parser.mly"
       (string)
# 24 "src/parser.ml"
  
    | NULL
    | NEWLINE
    | LPAREN
    | LBRACE
    | INTEGER of 
# 17 "src/parser.mly"
       (string)
# 33 "src/parser.ml"
  
    | IDENT of 
# 14 "src/parser.mly"
       (string)
# 38 "src/parser.ml"
  
    | FLOAT of 
# 18 "src/parser.mly"
       (float)
# 43 "src/parser.ml"
  
    | FALSE
    | EQ
    | EOF
    | DISABLE
  
end

include MenhirBasics

# 1 "src/parser.mly"
  
open Ast

let[@inline] cons_if_some x xs =
  match x with
  | None -> xs
  | Some x -> x :: xs

let error loc msg = raise @@ Err.CustomParsingError (msg, loc)

# 65 "src/parser.ml"

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

  | MenhirState001 : (('s, _menhir_box_document) _menhir_cell1_NEWLINE, _menhir_box_document) _menhir_state
    (** State 001.
        Stack shape : NEWLINE.
        Start symbol: document. *)

  | MenhirState005 : (('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_state
    (** State 005.
        Stack shape : list(NEWLINE).
        Start symbol: document. *)

  | MenhirState008 : (('s, _menhir_box_document) _menhir_cell1_LPAREN, _menhir_box_document) _menhir_state
    (** State 008.
        Stack shape : LPAREN.
        Start symbol: document. *)

  | MenhirState028 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_state
    (** State 028.
        Stack shape : list(NEWLINE) DISABLE.
        Start symbol: document. *)

  | MenhirState030 : (((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_LPAREN, _menhir_box_document) _menhir_state
    (** State 030.
        Stack shape : list(NEWLINE) DISABLE LPAREN.
        Start symbol: document. *)

  | MenhirState046 : (((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_state
    (** State 046.
        Stack shape : list(NEWLINE) DISABLE option(type_annot).
        Start symbol: document. *)

  | MenhirState047 : ((((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_cell1_name, _menhir_box_document) _menhir_state
    (** State 047.
        Stack shape : list(NEWLINE) DISABLE option(type_annot) name.
        Start symbol: document. *)

  | MenhirState053 : (('s, _menhir_box_document) _menhir_cell1_LBRACE, _menhir_box_document) _menhir_state
    (** State 053.
        Stack shape : LBRACE.
        Start symbol: document. *)

  | MenhirState054 : (('s, _menhir_box_document) _menhir_cell1_NEWLINE, _menhir_box_document) _menhir_state
    (** State 054.
        Stack shape : NEWLINE.
        Start symbol: document. *)

  | MenhirState059 : (('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_state
    (** State 059.
        Stack shape : list(NEWLINE).
        Start symbol: document. *)

  | MenhirState062 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_state
    (** State 062.
        Stack shape : list(NEWLINE) option(type_annot).
        Start symbol: document. *)

  | MenhirState073 : (((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_cell1_name, _menhir_box_document) _menhir_state
    (** State 073.
        Stack shape : list(NEWLINE) option(type_annot) name.
        Start symbol: document. *)

  | MenhirState079 : (('s, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_state
    (** State 079.
        Stack shape : DISABLE.
        Start symbol: document. *)

  | MenhirState083 : (('s, _menhir_box_document) _menhir_cell1_type_annot, _menhir_box_document) _menhir_state
    (** State 083.
        Stack shape : type_annot.
        Start symbol: document. *)

  | MenhirState090 : (('s, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ, _menhir_box_document) _menhir_state
    (** State 090.
        Stack shape : name EQ.
        Start symbol: document. *)

  | MenhirState092 : ((('s, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ, _menhir_box_document) _menhir_cell1_type_annot, _menhir_box_document) _menhir_state
    (** State 092.
        Stack shape : name EQ type_annot.
        Start symbol: document. *)

  | MenhirState097 : (('s, _menhir_box_document) _menhir_cell1_entity, _menhir_box_document) _menhir_state
    (** State 097.
        Stack shape : entity.
        Start symbol: document. *)

  | MenhirState101 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node, _menhir_box_document) _menhir_state
    (** State 101.
        Stack shape : list(NEWLINE) node.
        Start symbol: document. *)

  | MenhirState105 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node, _menhir_box_document) _menhir_state
    (** State 105.
        Stack shape : list(NEWLINE) node.
        Start symbol: document. *)

  | MenhirState110 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node, _menhir_box_document) _menhir_state
    (** State 110.
        Stack shape : list(NEWLINE) node.
        Start symbol: document. *)

  | MenhirState114 : ((('s, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node, _menhir_box_document) _menhir_state
    (** State 114.
        Stack shape : list(NEWLINE) node.
        Start symbol: document. *)


and ('s, 'r) _menhir_cell1_entity = 
  | MenhirCell1_entity of 's * ('s, 'r) _menhir_state * ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ])

and ('s, 'r) _menhir_cell1_list_NEWLINE_ = 
  | MenhirCell1_list_NEWLINE_ of 's * ('s, 'r) _menhir_state * (unit list)

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

and ('s, 'r) _menhir_cell1_node = 
  | MenhirCell1_node of 's * ('s, 'r) _menhir_state * (Ast.node option)

and ('s, 'r) _menhir_cell1_nodes = 
  | MenhirCell1_nodes of 's * ('s, 'r) _menhir_state * (Ast.t)

and ('s, 'r) _menhir_cell1_option_type_annot_ = 
  | MenhirCell1_option_type_annot_ of 's * ('s, 'r) _menhir_state * (string option) * Lexing.position

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

and ('s, 'r) _menhir_cell1_DISABLE = 
  | MenhirCell1_DISABLE of 's * ('s, 'r) _menhir_state

and 's _menhir_cell0_EQ = 
  | MenhirCell0_EQ of 's * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_IDENT = 
  | MenhirCell1_IDENT of 's * ('s, 'r) _menhir_state * 
# 14 "src/parser.mly"
       (string)
# 213 "src/parser.ml"
 * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_LBRACE = 
  | MenhirCell1_LBRACE of 's * ('s, 'r) _menhir_state * Lexing.position

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

and ('s, 'r) _menhir_cell1_NEWLINE = 
  | MenhirCell1_NEWLINE of 's * ('s, 'r) _menhir_state

and _menhir_box_document = 
  | MenhirBox_document of (Ast.t) [@@unboxed]

let _menhir_action_01 =
  fun xs ->
    (
# 174 "src/parser.mly"
                     ( xs )
# 233 "src/parser.ml"
     : (Ast.t))

let _menhir_action_02 =
  fun _endpos__3_ _startpos__1_ ->
    let _ = let _endpos = _endpos__3_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 175 "src/parser.mly"
                    ( error _sloc "Unterminated children block, expected a '}'" )
# 244 "src/parser.ml"
     : (Ast.t)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nchildren -> LBRACE nodes error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_03 =
  fun xs ->
    (
# 48 "src/parser.mly"
                       ( xs )
# 254 "src/parser.ml"
     : (Ast.t))

let _menhir_action_04 =
  fun () ->
    (
# 113 "src/parser.mly"
                     ( `Disabled )
# 262 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_05 =
  fun () ->
    (
# 114 "src/parser.mly"
                  ( `Disabled )
# 273 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_06 =
  fun x ->
    (
# 115 "src/parser.mly"
                  ( x )
# 284 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_07 =
  fun _endpos_x_ _startpos_x_ x ->
    let _endpos = _endpos_x_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 116 "src/parser.mly"
               ( `Children (x, _sloc) )
# 298 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_08 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 117 "src/parser.mly"
                      ( error _loc__x_ "Unexpected token '}'" )
# 310 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ])) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nentity -> DISABLE RBRACE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_09 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 323 "src/parser.ml"
     : (unit list))

let _menhir_action_10 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 331 "src/parser.ml"
     : (unit list))

let _menhir_action_11 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 339 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ] list))

let _menhir_action_12 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 350 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ] list))

let _menhir_action_13 =
  fun id ->
    (
# 51 "src/parser.mly"
             ( id )
# 361 "src/parser.ml"
     : (string))

let _menhir_action_14 =
  fun str ->
    (
# 52 "src/parser.mly"
               ( str )
# 369 "src/parser.ml"
     : (string))

let _menhir_action_15 =
  fun rstr ->
    (
# 53 "src/parser.mly"
                    ( rstr )
# 377 "src/parser.ml"
     : (string))

let _menhir_action_16 =
  fun () ->
    (
# 67 "src/parser.mly"
    ( None )
# 385 "src/parser.ml"
     : (Ast.node option))

let _menhir_action_17 =
  fun _endpos_annot_ _startpos_name_ annot entities name ->
    (
# 68 "src/parser.mly"
                                                 (
    let ws_after_annot = Option.is_some annot
      && Lexing.(_endpos_annot_.pos_cnum <> _startpos_name_.pos_cnum) in
    if ws_after_annot then
      error (_endpos_annot_, _startpos_name_)
        "Whitespace after a type annotation is not allowed";
    let known_props : (string, prop) Hashtbl.t = Hashtbl.create 4 in
    let f (args, props, children) entity =
      match entity, children with
      | `Disabled, _ -> args, props, children
      | `Children (_, loc), Some _ ->
        error loc "A children block must be defined only once"
      | `Children c, None -> args, props, Some c
      | (`Prop _ | `Arg _), Some (_, loc) ->
        error loc "A children block must be the last element of a node"
      | `Arg a, _ -> a :: args, props, children
      (* This is not optimal, but should be fine for most cases.
         Every prop is checked against the known_props hash table, this
         operates in O(1) on average. If the prop has been already defined,
         it is removed from the list in O(n) time. It is assumed that
         redefinitions of properties should be rare. *)
      | `Prop (name, _ as p), _ when Hashtbl.mem known_props name ->
        args, p :: List.filter (fun (n, _) -> n <> name) props, children
      | `Prop (name, _ as p), _ ->
        Hashtbl.add known_props name p;
        args, p :: props, children
    in
    let args, props, children_opt = List.fold_left f ([], [], None) entities in
    let children = match children_opt with None -> [] | Some (xs, _loc) -> xs in
    let args = List.rev args in
    let props = List.rev props in
    Some { name; annot; args; props; children }
  )
# 425 "src/parser.ml"
     : (Ast.node option))

let _menhir_action_18 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 101 "src/parser.mly"
                              ( error _loc__x_ "'true' is not a valid node name" )
# 434 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> option(type_annot) TRUE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_19 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 102 "src/parser.mly"
                               ( error _loc__x_ "'false' is not a valid node name" )
# 445 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> option(type_annot) FALSE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_20 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 103 "src/parser.mly"
                              ( error _loc__x_ "'null' is not a valid node name" )
# 456 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> option(type_annot) NULL error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_21 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 104 "src/parser.mly"
                                 ( error _loc__x_ "A number is not a valid node name" )
# 467 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> option(type_annot) INTEGER error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_22 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 105 "src/parser.mly"
                               ( error _loc__x_ "A number is not a valid node name" )
# 478 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> option(type_annot) FLOAT error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_23 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 106 "src/parser.mly"
                        ( error _loc__x_ "Expected a node name" )
# 489 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> type_annot error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_24 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 107 "src/parser.mly"
                  ( error _loc__x_ "Expected a node after a '/-'")
# 500 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> DISABLE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_25 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 108 "src/parser.mly"
                 ( error _loc__x_ "Unexpected token ')'" )
# 511 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> RPAREN error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_26 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 109 "src/parser.mly"
                 ( error _loc__x_ "Unexpected token '='" )
# 522 "src/parser.ml"
     : (Ast.node option)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnode -> EQ error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_27 =
  fun () ->
    (
# 57 "src/parser.mly"
             ( [] )
# 532 "src/parser.ml"
     : (Ast.t))

let _menhir_action_28 =
  fun x ->
    (
# 58 "src/parser.mly"
                        ( cons_if_some x [] )
# 540 "src/parser.ml"
     : (Ast.t))

let _menhir_action_29 =
  fun x xs ->
    (
# 59 "src/parser.mly"
                                 ( cons_if_some x xs )
# 548 "src/parser.ml"
     : (Ast.t))

let _menhir_action_30 =
  fun x xs ->
    (
# 60 "src/parser.mly"
                                     ( cons_if_some x xs )
# 556 "src/parser.ml"
     : (Ast.t))

let _menhir_action_31 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 62 "src/parser.mly"
    ( error _loc__x_ "A node should be terminated with a semicolon or newline" )
# 565 "src/parser.ml"
     : (Ast.t)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nnodes -> list(NEWLINE) node RBRACE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_32 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 575 "src/parser.ml"
     : (string option))

let _menhir_action_33 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 583 "src/parser.ml"
     : (string option))

let _menhir_action_34 =
  fun _endpos__eq_ _endpos_annot_ _endpos_key_ _eq _startpos__eq_ _startpos_annot_ _startpos_value_ annot key value ->
    let aval = 
# 133 "src/parser.mly"
                                 (
    if Lexing.(_endpos_annot_.pos_cnum <> _startpos_value_.pos_cnum) then
      error (_endpos_annot_, _startpos_value_)
        "Whitespace after a type annotation is not allowed";
    Some annot, value
  )
# 596 "src/parser.ml"
     in
    let _startpos_aval_ = _startpos_annot_ in
    (
# 122 "src/parser.mly"
                                      (
    if Lexing.(_endpos_key_.pos_cnum <> _startpos__eq_.pos_cnum) then
      error (_endpos_key_, _startpos__eq_) "Whitespace before '=' is not allowed";
    if Lexing.(_endpos__eq_.pos_cnum <> _startpos_aval_.pos_cnum) then
      error (_endpos__eq_, _startpos_aval_) "Whitespace after '=' is not allowed";
    `Prop (key, aval)
  )
# 608 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_35 =
  fun _endpos__eq_ _endpos_key_ _eq _startpos__eq_ _startpos_value_ key value ->
    let aval = 
# 139 "src/parser.mly"
                ( None, value )
# 619 "src/parser.ml"
     in
    let _startpos_aval_ = _startpos_value_ in
    (
# 122 "src/parser.mly"
                                      (
    if Lexing.(_endpos_key_.pos_cnum <> _startpos__eq_.pos_cnum) then
      error (_endpos_key_, _startpos__eq_) "Whitespace before '=' is not allowed";
    if Lexing.(_endpos__eq_.pos_cnum <> _startpos_aval_.pos_cnum) then
      error (_endpos__eq_, _startpos_aval_) "Whitespace after '=' is not allowed";
    `Prop (key, aval)
  )
# 631 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_36 =
  fun _endpos_annot_ _startpos_value_ annot value ->
    let aval = 
# 133 "src/parser.mly"
                                 (
    if Lexing.(_endpos_annot_.pos_cnum <> _startpos_value_.pos_cnum) then
      error (_endpos_annot_, _startpos_value_)
        "Whitespace after a type annotation is not allowed";
    Some annot, value
  )
# 647 "src/parser.ml"
     in
    (
# 129 "src/parser.mly"
                     ( `Arg aval )
# 652 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_37 =
  fun value ->
    let aval = 
# 139 "src/parser.mly"
                ( None, value )
# 663 "src/parser.ml"
     in
    (
# 129 "src/parser.mly"
                     ( `Arg aval )
# 668 "src/parser.ml"
     : ([ `Arg of Ast.annot_value
  | `Children of Ast.t * Loc.t
  | `Disabled
  | `Prop of string * Ast.annot_value ]))

let _menhir_action_38 =
  fun typ ->
    (
# 163 "src/parser.mly"
                     ( typ )
# 679 "src/parser.ml"
     : (string))

let _menhir_action_39 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 164 "src/parser.mly"
                      ( error _loc__x_ "Expected a ')'" )
# 688 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN name error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_40 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 165 "src/parser.mly"
                      ( error _loc__x_ "'true' is not a valid type annotation name" )
# 699 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN TRUE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_41 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 166 "src/parser.mly"
                       ( error _loc__x_ "'false' is not a valid type annotation name" )
# 710 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN FALSE error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_42 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 167 "src/parser.mly"
                      ( error _loc__x_ "'null' is not a valid type annotation name" )
# 721 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN NULL error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_43 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 168 "src/parser.mly"
                         ( error _loc__x_ "A number is not a valid type annotation name" )
# 732 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN INTEGER error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_44 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 169 "src/parser.mly"
                       ( error _loc__x_ "A number is not a valid type annotation name" )
# 743 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN FLOAT error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_45 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 170 "src/parser.mly"
                 ( error _loc__x_ "Expected a type annotation name" )
# 754 "src/parser.ml"
     : (string)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\ntype_annot -> LPAREN error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_46 =
  fun str ->
    (
# 143 "src/parser.mly"
               ( `String str )
# 764 "src/parser.ml"
     : (Ast.value))

let _menhir_action_47 =
  fun str ->
    (
# 144 "src/parser.mly"
                   ( `String str )
# 772 "src/parser.ml"
     : (Ast.value))

let _menhir_action_48 =
  fun int_str ->
    (
# 145 "src/parser.mly"
                    (
    (* TODO: Even if the input is positive, int_of_string_opt can return a
       negative integer for 0x / 0o / 0b prefixes instead of using `RawInt as
       the fallback. We probably want to avoid this behavior and be consistent
       regardless of the prefix. *)
    match int_of_string_opt int_str with
    | Some int -> `Int int
    | None -> `RawInt int_str
  )
# 788 "src/parser.ml"
     : (Ast.value))

let _menhir_action_49 =
  fun float ->
    (
# 154 "src/parser.mly"
                ( `Float float )
# 796 "src/parser.ml"
     : (Ast.value))

let _menhir_action_50 =
  fun () ->
    (
# 155 "src/parser.mly"
         ( `Bool true )
# 804 "src/parser.ml"
     : (Ast.value))

let _menhir_action_51 =
  fun () ->
    (
# 156 "src/parser.mly"
          ( `Bool false )
# 812 "src/parser.ml"
     : (Ast.value))

let _menhir_action_52 =
  fun () ->
    (
# 157 "src/parser.mly"
         ( `Null )
# 820 "src/parser.ml"
     : (Ast.value))

let _menhir_action_53 =
  fun _endpos__x_ _startpos__x_ _x ->
    let _ = let _loc__x_ = (_startpos__x_, _endpos__x_) in
    (
# 158 "src/parser.mly"
                   ( error _loc__x_ "Expected a value, got an identifier" )
# 829 "src/parser.ml"
     : (Ast.value)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nvalue -> IDENT error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_action_54 =
  fun _endpos__1_ _startpos__1_ ->
    let _ = let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 159 "src/parser.mly"
          ( error _sloc "Expected a value" )
# 842 "src/parser.ml"
     : (Ast.value)) in
    prerr_string "Menhir: misuse: the semantic action associated with the production\nvalue -> error\nis expected to abort the parser, but does not do so.\n";
    assert false

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | TRUE ->
        "TRUE"
    | STRING _ ->
        "STRING"
    | SEMI ->
        "SEMI"
    | RPAREN ->
        "RPAREN"
    | RBRACE ->
        "RBRACE"
    | RAW_STRING _ ->
        "RAW_STRING"
    | NULL ->
        "NULL"
    | NEWLINE ->
        "NEWLINE"
    | LPAREN ->
        "LPAREN"
    | LBRACE ->
        "LBRACE"
    | INTEGER _ ->
        "INTEGER"
    | IDENT _ ->
        "IDENT"
    | FLOAT _ ->
        "FLOAT"
    | FALSE ->
        "FALSE"
    | EQ ->
        "EQ"
    | EOF ->
        "EOF"
    | DISABLE ->
        "DISABLE"

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_error_goto_node : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_s ->
      match _menhir_s with
      | MenhirState059 ->
          _eRR ()
      | MenhirState005 ->
          _eRR ()
      | _ ->
          _menhir_fail ()
  
  let _menhir_run_006 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | _ ->
          let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
          let _ = _menhir_action_25 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_node _menhir_stack _menhir_s
  
  let _menhir_error_goto_option_type_annot_ : type  ttv_stack. ttv_stack -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_s ->
      match _menhir_s with
      | MenhirState028 ->
          _eRR ()
      | MenhirState005 ->
          _eRR ()
      | MenhirState059 ->
          _eRR ()
      | _ ->
          _menhir_fail ()
  
  let _menhir_error_run_045 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE as 'stack) -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _v _menhir_s ->
      let x = _v in
      let _ = _menhir_action_33 x in
      _menhir_error_goto_option_type_annot_ _menhir_stack _menhir_s
  
  let _menhir_error_run_061 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_type_annot -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let MenhirCell1_type_annot (_menhir_stack, _menhir_s, _, _, _) = _menhir_stack in
      let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
      let _ = _menhir_action_23 _endpos__x_ _startpos__x_ _x in
      _menhir_error_goto_node _menhir_stack _menhir_s
  
  let _menhir_error_run_060 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      _menhir_error_run_061 _menhir_stack _menhir_lexbuf
  
  let rec _menhir_error_run_048 : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_54 _endpos__1_ _startpos__1_ in
      _menhir_error_goto_value _menhir_stack _menhir_lexbuf _startpos__1_ _v _menhir_s
  
  and _menhir_error_goto_value : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _startpos _v _menhir_s ->
      match _menhir_s with
      | MenhirState047 ->
          _menhir_error_run_082 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState073 ->
          _menhir_error_run_082 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState079 ->
          _menhir_error_run_082 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState097 ->
          _menhir_error_run_082 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState083 ->
          _menhir_error_run_087 _menhir_stack _menhir_lexbuf _startpos _v
      | MenhirState090 ->
          _menhir_error_run_091 _menhir_stack _menhir_lexbuf _startpos _v
      | MenhirState092 ->
          _menhir_error_run_093 _menhir_stack _menhir_lexbuf _startpos _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_error_run_082 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      let value = _v in
      let _v = _menhir_action_37 value in
      _menhir_error_goto_prop_or_arg _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_goto_prop_or_arg : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      match _menhir_s with
      | MenhirState079 ->
          _menhir_error_run_088 _menhir_stack _menhir_lexbuf
      | MenhirState047 ->
          _menhir_error_run_095 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState073 ->
          _menhir_error_run_095 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState097 ->
          _menhir_error_run_095 _menhir_stack _menhir_lexbuf _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  and _menhir_error_run_088 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_DISABLE -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf ->
      let MenhirCell1_DISABLE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _v = _menhir_action_04 () in
      _menhir_error_goto_entity _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_goto_entity : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      let _menhir_stack = MenhirCell1_entity (_menhir_stack, _menhir_s, _v) in
      _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState097
  
  and _menhir_error_run_095 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      let x = _v in
      let _v = _menhir_action_06 x in
      _menhir_error_goto_entity _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_087 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_type_annot -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _startpos _v ->
      let MenhirCell1_type_annot (_menhir_stack, _menhir_s, annot, _, _endpos_annot_) = _menhir_stack in
      let (_startpos_value_, value) = (_startpos, _v) in
      let _v = _menhir_action_36 _endpos_annot_ _startpos_value_ annot value in
      _menhir_error_goto_prop_or_arg _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_091 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _startpos _v ->
      let MenhirCell0_EQ (_menhir_stack, _startpos__eq_, _endpos__eq_) = _menhir_stack in
      let MenhirCell1_name (_menhir_stack, _menhir_s, key, _, _endpos_key_) = _menhir_stack in
      let (_startpos_value_, value, _eq) = (_startpos, _v, ()) in
      let _v = _menhir_action_35 _endpos__eq_ _endpos_key_ _eq _startpos__eq_ _startpos_value_ key value in
      _menhir_error_goto_prop_or_arg _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_093 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ, _menhir_box_document) _menhir_cell1_type_annot -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _startpos _v ->
      let MenhirCell1_type_annot (_menhir_stack, _, annot, _startpos_annot_, _endpos_annot_) = _menhir_stack in
      let MenhirCell0_EQ (_menhir_stack, _startpos__eq_, _endpos__eq_) = _menhir_stack in
      let MenhirCell1_name (_menhir_stack, _menhir_s, key, _, _endpos_key_) = _menhir_stack in
      let (_startpos_value_, value, _eq) = (_startpos, _v, ()) in
      let _v = _menhir_action_34 _endpos__eq_ _endpos_annot_ _endpos_key_ _eq _startpos__eq_ _startpos_annot_ _startpos_value_ annot key value in
      _menhir_error_goto_prop_or_arg _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let _menhir_error_run_083 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState083
  
  let _menhir_error_run_092 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState092
  
  let _menhir_error_goto_type_annot : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      match _menhir_s with
      | MenhirState028 ->
          _menhir_error_run_045 _menhir_stack _v _menhir_s
      | MenhirState005 ->
          _menhir_error_run_060 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState059 ->
          _menhir_error_run_060 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState047 ->
          _menhir_error_run_083 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState073 ->
          _menhir_error_run_083 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState079 ->
          _menhir_error_run_083 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState097 ->
          _menhir_error_run_083 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState090 ->
          _menhir_error_run_092 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  let _menhir_error_run_094 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_DISABLE -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf ->
      let MenhirCell1_DISABLE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _v = _menhir_action_05 () in
      _menhir_error_goto_entity _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let _menhir_error_run_099 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_07 _endpos_x_ _startpos_x_ x in
      _menhir_error_goto_entity _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let _menhir_error_goto_children : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      match _menhir_s with
      | MenhirState079 ->
          _menhir_error_run_094 _menhir_stack _menhir_lexbuf
      | MenhirState047 ->
          _menhir_error_run_099 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState073 ->
          _menhir_error_run_099 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | MenhirState097 ->
          _menhir_error_run_099 _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s
      | _ ->
          _menhir_fail ()
  
  let _menhir_error_run_057 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_LBRACE, _menhir_box_document) _menhir_cell1_nodes -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let MenhirCell1_nodes (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_02 _endpos__3_ _startpos__1_ in
      _menhir_error_goto_children _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s
  
  let _menhir_error_run_056 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_LBRACE as 'stack) -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      let _menhir_stack = MenhirCell1_nodes (_menhir_stack, _menhir_s, _v) in
      _menhir_error_run_057 _menhir_stack _menhir_lexbuf
  
  let rec _menhir_error_goto_nodes : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      match _menhir_s with
      | MenhirState000 ->
          _eRR ()
      | MenhirState053 ->
          _menhir_error_run_056 _menhir_stack _menhir_lexbuf _v _menhir_s
      | MenhirState101 ->
          _menhir_error_run_102 _menhir_stack _menhir_lexbuf _v
      | MenhirState105 ->
          _menhir_error_run_106 _menhir_stack _menhir_lexbuf _v
      | MenhirState110 ->
          _menhir_error_run_111 _menhir_stack _menhir_lexbuf _v
      | MenhirState114 ->
          _menhir_error_run_115 _menhir_stack _menhir_lexbuf _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_error_run_102 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_29 x xs in
      _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_106 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_30 x xs in
      _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_111 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_29 x xs in
      _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_run_115 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_30 x xs in
      _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let _menhir_error_run_059 : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_s ->
      let _v = _menhir_action_27 () in
      _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let rec _menhir_error_run_055 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_NEWLINE -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) = _menhir_stack in
      let (xs, x) = (_v, ()) in
      let _v = _menhir_action_10 x xs in
      _menhir_error_goto_list_NEWLINE_ _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_error_goto_list_NEWLINE_ : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v _menhir_s ->
      match _menhir_s with
      | MenhirState001 ->
          _menhir_error_run_002 _menhir_stack _menhir_lexbuf _v
      | MenhirState000 ->
          _eRR ()
      | MenhirState110 ->
          _eRR ()
      | MenhirState114 ->
          _eRR ()
      | MenhirState054 ->
          _menhir_error_run_055 _menhir_stack _menhir_lexbuf _v
      | MenhirState053 ->
          _menhir_error_run_059 _menhir_stack _menhir_lexbuf _menhir_s
      | MenhirState101 ->
          _menhir_error_run_059 _menhir_stack _menhir_lexbuf _menhir_s
      | MenhirState105 ->
          _menhir_error_run_059 _menhir_stack _menhir_lexbuf _menhir_s
      | _ ->
          _menhir_fail ()
  
  and _menhir_error_run_002 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_NEWLINE -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _v ->
      let MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) = _menhir_stack in
      let (xs, x) = (_v, ()) in
      let _v = _menhir_action_10 x xs in
      _menhir_error_goto_list_NEWLINE_ _menhir_stack _menhir_lexbuf _v _menhir_s
  
  let _menhir_run_026 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | _ ->
          let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
          let _ = _menhir_action_26 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_node _menhir_stack _menhir_s
  
  let _menhir_run_003 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let xs = _v in
          let _v = _menhir_action_03 xs in
          MenhirBox_document _v
      | _ ->
          _eRR ()
  
  let _menhir_error_run_076 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_IDENT -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf ->
      let MenhirCell1_IDENT (_menhir_stack, _menhir_s, _x, _startpos__x_, _endpos__x_) = _menhir_stack in
      let _v = _menhir_action_53 _endpos__x_ _startpos__x_ _x in
      _menhir_error_goto_value _menhir_stack _menhir_lexbuf _startpos__x_ _v _menhir_s
  
  let _menhir_run_086 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | _ ->
          _menhir_error_run_076 _menhir_stack _menhir_lexbuf
  
  let rec _menhir_run_001 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NEWLINE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
      | DISABLE | EOF | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RPAREN | STRING _ | TRUE ->
          let _v = _menhir_action_09 () in
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_002 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_NEWLINE -> _ -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) = _menhir_stack in
      let (xs, x) = (_v, ()) in
      let _v = _menhir_action_10 x xs in
      _menhir_goto_list_NEWLINE_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_list_NEWLINE_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState001 ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState000 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState110 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState114 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState054 ->
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState053 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState101 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState105 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_005 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState005
      | LPAREN ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState005
      | EQ ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState005
      | DISABLE ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_028 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState005
      | EOF ->
          let _v = _menhir_action_27 () in
          _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | FALSE | FLOAT _ | IDENT _ | INTEGER _ | NULL | RAW_STRING _ | STRING _ | TRUE ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          let _v_0 = _menhir_action_32 () in
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState005 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_008 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__1_, _endpos__x_, _startpos__x_, _x, _endpos__3_) = (_startpos, _endpos, _startpos_0, (), _endpos_2) in
              let _v = _menhir_action_40 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s)
      | STRING _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | RAW_STRING _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | NULL ->
          let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__1_, _endpos__x_, _startpos__x_, _x, _endpos__3_) = (_startpos, _endpos, _startpos_3, (), _endpos_5) in
              let _v = _menhir_action_42 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s)
      | INTEGER _v ->
          let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__1_, _endpos__x_, _startpos__x_, _x, _endpos__3_) = (_startpos, _endpos, _startpos_6, _v, _endpos_8) in
              let _v = _menhir_action_43 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s)
      | IDENT _v ->
          let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos) in
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState008
      | FLOAT _v ->
          let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let _endpos_11 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__1_, _endpos__x_, _startpos__x_, _x, _endpos__3_) = (_startpos, _endpos, _startpos_9, _v, _endpos_11) in
              let _v = _menhir_action_44 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s)
      | FALSE ->
          let _startpos_12 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
              let (_startpos__1_, _endpos__x_, _startpos__x_, _x, _endpos__3_) = (_startpos, _endpos, _startpos_12, (), _endpos_14) in
              let _v = _menhir_action_41 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__3_ _startpos__1_ _v _menhir_s)
      | _ ->
          let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_startpos__1_, _endpos__x_, _startpos__x_, _x) = (_startpos, _endpos, _startpos_15, ()) in
          let _v = _menhir_action_45 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__x_ _startpos__1_ _v _menhir_s
  
  and _menhir_run_012 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_str_, _startpos_str_, str) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_14 str in
      _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_str_ _startpos_str_ _v _menhir_s _tok
  
  and _menhir_goto_name : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState008 ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState030 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState046 ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState062 ->
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState047 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState079 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_023 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_LPAREN -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__3_, typ) = (_endpos_1, _v) in
          let _v = _menhir_action_38 typ in
          _menhir_goto_type_annot _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__x_, _startpos__x_, _x) = (_endpos_3, _startpos_2, ()) in
          let _v = _menhir_action_39 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__x_ _startpos__1_ _v _menhir_s
  
  and _menhir_goto_type_annot : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState028 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState005 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState059 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState047 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState079 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState090 ->
          _menhir_run_092 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_045 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let (_endpos_x_, x) = (_endpos, _v) in
      let _v = _menhir_action_33 x in
      _menhir_goto_option_type_annot_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_option_type_annot_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState028 ->
          _menhir_run_046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState005 ->
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState059 ->
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_046 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_type_annot_ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | STRING _v_0 ->
          _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState046
      | RAW_STRING _v_1 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState046
      | IDENT _v_2 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState046
      | _ ->
          _eRR ()
  
  and _menhir_run_013 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_rstr_, _startpos_rstr_, rstr) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_15 rstr in
      _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rstr_ _startpos_rstr_ _v _menhir_s _tok
  
  and _menhir_run_018 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_13 id in
      _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
  
  and _menhir_run_062 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos_0, _startpos, ()) in
              let _ = _menhir_action_18 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_node _menhir_stack _menhir_s)
      | STRING _v_3 ->
          let _menhir_stack = MenhirCell1_option_type_annot_ (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState062
      | RAW_STRING _v_4 ->
          let _menhir_stack = MenhirCell1_option_type_annot_ (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState062
      | NULL ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos_5, _startpos, ()) in
              let _ = _menhir_action_20 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_node _menhir_stack _menhir_s)
      | INTEGER _v_8 ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_9 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos_9, _startpos, _v_8) in
              let _ = _menhir_action_21 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_node _menhir_stack _menhir_s)
      | IDENT _v_12 ->
          let _menhir_stack = MenhirCell1_option_type_annot_ (_menhir_stack, _menhir_s, _v, _endpos) in
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState062
      | FLOAT _v_13 ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos_14, _startpos, _v_13) in
              let _ = _menhir_action_22 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_node _menhir_stack _menhir_s)
      | FALSE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_17 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos_17, _startpos, ()) in
              let _ = _menhir_action_19 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_node _menhir_stack _menhir_s)
      | _ ->
          _eRR ()
  
  and _menhir_run_060 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | FALSE | FLOAT _ | IDENT _ | INTEGER _ | NULL | RAW_STRING _ | STRING _ | TRUE ->
          let (_endpos_x_, x) = (_endpos, _v) in
          let _v = _menhir_action_33 x in
          _menhir_goto_option_type_annot_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok
      | _ ->
          let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_error_run_061 _menhir_stack _menhir_lexbuf
  
  and _menhir_run_083 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState083
      | STRING _v_0 ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState083
      | RAW_STRING _v_1 ->
          _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState083
      | NULL ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState083
      | INTEGER _v_2 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState083
      | IDENT _v_3 ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState083
      | FLOAT _v_4 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState083
      | FALSE ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState083
      | _ ->
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState083
  
  and _menhir_run_049 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_50 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_value : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState047 ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState079 ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState083 ->
          _menhir_run_087 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok
      | MenhirState090 ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok
      | MenhirState092 ->
          _menhir_run_093 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_082 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let value = _v in
      let _v = _menhir_action_37 value in
      _menhir_goto_prop_or_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_prop_or_arg : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState079 ->
          _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState047 ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_088 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_DISABLE -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_DISABLE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _v = _menhir_action_04 () in
      _menhir_goto_entity _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_entity : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_entity (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | STRING _v_0 ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState097
      | RAW_STRING _v_1 ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState097
      | NULL ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | LBRACE ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | INTEGER _v_2 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState097
      | IDENT _v_3 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState097
      | FLOAT _v_4 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState097
      | FALSE ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | DISABLE ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState097
      | EOF | NEWLINE | RBRACE | SEMI ->
          let _v_5 = _menhir_action_11 () in
          _menhir_run_098 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 _tok
      | _ ->
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState097
  
  and _menhir_run_050 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EQ ->
          let (_endpos_str_, _startpos_str_, str) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_14 str in
          _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_str_ _startpos_str_ _v _menhir_s _tok
      | DISABLE | EOF | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LBRACE | LPAREN | NEWLINE | NULL | RAW_STRING _ | RBRACE | SEMI | STRING _ | TRUE ->
          let (_startpos_str_, str) = (_startpos, _v) in
          let _v = _menhir_action_46 str in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_str_ _v _menhir_s _tok
      | _ ->
          let (_startpos_str_, str) = (_startpos, _v) in
          let _v = _menhir_action_46 str in
          _menhir_error_goto_value _menhir_stack _menhir_lexbuf _startpos_str_ _v _menhir_s
  
  and _menhir_run_051 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EQ ->
          let (_endpos_rstr_, _startpos_rstr_, rstr) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_15 rstr in
          _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rstr_ _startpos_rstr_ _v _menhir_s _tok
      | DISABLE | EOF | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LBRACE | LPAREN | NEWLINE | NULL | RAW_STRING _ | RBRACE | SEMI | STRING _ | TRUE ->
          let (_startpos_str_, str) = (_startpos, _v) in
          let _v = _menhir_action_47 str in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_str_ _v _menhir_s _tok
      | _ ->
          let (_startpos_str_, str) = (_startpos, _v) in
          let _v = _menhir_action_47 str in
          _menhir_error_goto_value _menhir_stack _menhir_lexbuf _startpos_str_ _v _menhir_s
  
  and _menhir_run_052 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_52 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_053 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NEWLINE ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState053
      | DISABLE | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RBRACE | RPAREN | STRING _ | TRUE ->
          let _v = _menhir_action_09 () in
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v MenhirState053 _tok
      | _ ->
          let _ = _menhir_action_09 () in
          _menhir_error_run_059 _menhir_stack _menhir_lexbuf MenhirState053
  
  and _menhir_run_054 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NEWLINE ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState054
      | DISABLE | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RBRACE | RPAREN | STRING _ | TRUE ->
          let _v = _menhir_action_09 () in
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          let _v = _menhir_action_09 () in
          _menhir_error_run_055 _menhir_stack _menhir_lexbuf _v
  
  and _menhir_run_055 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_NEWLINE -> _ -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_NEWLINE (_menhir_stack, _menhir_s) = _menhir_stack in
      let (xs, x) = (_v, ()) in
      let _v = _menhir_action_10 x xs in
      _menhir_goto_list_NEWLINE_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_059 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_006 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState059
      | LPAREN ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState059
      | EQ ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState059
      | DISABLE ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          _menhir_run_028 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState059
      | RBRACE ->
          let _v = _menhir_action_27 () in
          _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | FALSE | FLOAT _ | IDENT _ | INTEGER _ | NULL | RAW_STRING _ | STRING _ | TRUE ->
          let _menhir_stack = MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _v) in
          let _v_0 = _menhir_action_32 () in
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState059 _tok
      | _ ->
          let _v = _menhir_action_27 () in
          _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s
  
  and _menhir_run_028 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LPAREN ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TRUE ->
              let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | _ ->
                  let _v =
                    let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_0, ()) in
                    _menhir_action_40 _endpos__x_ _startpos__x_ _x
                  in
                  _menhir_error_run_045 _menhir_stack _v MenhirState028)
          | STRING _v ->
              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, MenhirState028, _startpos) in
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState030
          | RAW_STRING _v ->
              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, MenhirState028, _startpos) in
              _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState030
          | NULL ->
              let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | _ ->
                  let _v =
                    let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_3, ()) in
                    _menhir_action_42 _endpos__x_ _startpos__x_ _x
                  in
                  _menhir_error_run_045 _menhir_stack _v MenhirState028)
          | INTEGER _v ->
              let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | _ ->
                  let _v =
                    let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_6, _v) in
                    _menhir_action_43 _endpos__x_ _startpos__x_ _x
                  in
                  _menhir_error_run_045 _menhir_stack _v MenhirState028)
          | IDENT _v ->
              let _menhir_stack = MenhirCell1_LPAREN (_menhir_stack, MenhirState028, _startpos) in
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState030
          | FLOAT _v ->
              let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | _ ->
                  let _v =
                    let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_9, _v) in
                    _menhir_action_44 _endpos__x_ _startpos__x_ _x
                  in
                  _menhir_error_run_045 _menhir_stack _v MenhirState028)
          | FALSE ->
              let _startpos_12 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | _ ->
                  let _v =
                    let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_12, ()) in
                    _menhir_action_41 _endpos__x_ _startpos__x_ _x
                  in
                  _menhir_error_run_045 _menhir_stack _v MenhirState028)
          | _ ->
              let _startpos_15 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _v =
                let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos_15, ()) in
                _menhir_action_45 _endpos__x_ _startpos__x_ _x
              in
              _menhir_error_run_045 _menhir_stack _v MenhirState028)
      | IDENT _ | RAW_STRING _ | STRING _ ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          let _v = _menhir_action_32 () in
          _menhir_run_046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v MenhirState028 _tok
      | _ ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
          let _ = _menhir_action_24 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_node _menhir_stack _menhir_s
  
  and _menhir_goto_nodes : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState000 ->
          _menhir_run_003 _menhir_stack _v _tok
      | MenhirState053 ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState101 ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState105 ->
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState110 ->
          _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState114 ->
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_056 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_LBRACE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | RBRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LBRACE (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (xs, _endpos__3_) = (_v, _endpos) in
          let _v = _menhir_action_01 xs in
          _menhir_goto_children _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          let _menhir_stack = MenhirCell1_nodes (_menhir_stack, _menhir_s, _v) in
          _menhir_error_run_057 _menhir_stack _menhir_lexbuf
  
  and _menhir_goto_children : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState079 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState047 ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_094 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_DISABLE -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_DISABLE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _v = _menhir_action_05 () in
      _menhir_goto_entity _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_099 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_07 _endpos_x_ _startpos_x_ x in
      _menhir_goto_entity _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_102 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_29 x xs in
      _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_106 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_30 x xs in
      _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_111 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_29 x xs in
      _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_115 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_node -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_node (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_30 x xs in
      _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_074 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_int_str_, int_str) = (_startpos, _v) in
      let _v = _menhir_action_48 int_str in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_int_str_ _v _menhir_s _tok
  
  and _menhir_run_075 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EQ ->
          let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_13 id in
          _menhir_goto_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_error_run_076 _menhir_stack _menhir_lexbuf
  
  and _menhir_run_077 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_float_, float) = (_startpos, _v) in
      let _v = _menhir_action_49 float in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_float_ _v _menhir_s _tok
  
  and _menhir_run_078 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _startpos__1_ = _startpos in
      let _v = _menhir_action_51 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_079 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | STRING _v ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState079
      | RBRACE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
              let _v = _menhir_action_08 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_entity _menhir_stack _menhir_lexbuf _v _menhir_s)
      | RAW_STRING _v ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState079
      | NULL ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | LPAREN ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | LBRACE ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | INTEGER _v ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState079
      | IDENT _v ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState079
      | FLOAT _v ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState079
      | FALSE ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState079
      | _ ->
          let _menhir_stack = MenhirCell1_DISABLE (_menhir_stack, _menhir_s) in
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState079
  
  and _menhir_run_098 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_entity -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_entity (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_12 x xs in
      _menhir_goto_list_entity_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_list_entity_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState073 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState097 ->
          _menhir_run_098 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState047 ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_096 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_cell1_name -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_name (_menhir_stack, _, name, _startpos_name_, _) = _menhir_stack in
      let MenhirCell1_option_type_annot_ (_menhir_stack, _menhir_s, annot, _endpos_annot_) = _menhir_stack in
      let entities = _v in
      let _v = _menhir_action_17 _endpos_annot_ _startpos_name_ annot entities name in
      _menhir_goto_node _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_node : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState059 ->
          _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState005 ->
          _menhir_run_109 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_100 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMI ->
          let _menhir_stack = MenhirCell1_node (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NEWLINE ->
              _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState101
          | DISABLE | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RBRACE | RPAREN | STRING _ | TRUE ->
              let _v_0 = _menhir_action_09 () in
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState101 _tok
          | _ ->
              let _ = _menhir_action_09 () in
              _menhir_error_run_059 _menhir_stack _menhir_lexbuf MenhirState101)
      | RBRACE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
              let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
              let _v = _menhir_action_31 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s)
      | NEWLINE ->
          let _menhir_stack = MenhirCell1_node (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NEWLINE ->
              _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
          | DISABLE | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RBRACE | RPAREN | STRING _ | TRUE ->
              let _v_4 = _menhir_action_09 () in
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_4 MenhirState105 _tok
          | _ ->
              let _ = _menhir_action_09 () in
              _menhir_error_run_059 _menhir_stack _menhir_lexbuf MenhirState105)
      | EOF ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
          let x = _v in
          let _v = _menhir_action_28 x in
          _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_109 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_ as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMI ->
          let _menhir_stack = MenhirCell1_node (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NEWLINE ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState110
          | DISABLE | EOF | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RPAREN | STRING _ | TRUE ->
              let _v_0 = _menhir_action_09 () in
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState110 _tok
          | _ ->
              _eRR ())
      | RBRACE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | _ ->
              let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
              let (_endpos__x_, _startpos__x_, _x) = (_endpos, _startpos, ()) in
              let _v = _menhir_action_31 _endpos__x_ _startpos__x_ _x in
              _menhir_error_goto_nodes _menhir_stack _menhir_lexbuf _v _menhir_s)
      | NEWLINE ->
          let _menhir_stack = MenhirCell1_node (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NEWLINE ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState114
          | DISABLE | EOF | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RPAREN | STRING _ | TRUE ->
              let _v_3 = _menhir_action_09 () in
              _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_3 MenhirState114 _tok
          | _ ->
              _eRR ())
      | EOF ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_list_NEWLINE_ (_menhir_stack, _menhir_s, _) = _menhir_stack in
          let x = _v in
          let _v = _menhir_action_28 x in
          _menhir_goto_nodes _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_108 : type  ttv_stack. ((((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_option_type_annot_, _menhir_box_document) _menhir_cell1_name -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_name (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_option_type_annot_ (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_DISABLE (_menhir_stack, _menhir_s) = _menhir_stack in
      let _v = _menhir_action_16 () in
      _menhir_goto_node _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_095 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let x = _v in
      let _v = _menhir_action_06 x in
      _menhir_goto_entity _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_087 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_type_annot -> _ -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok ->
      let MenhirCell1_type_annot (_menhir_stack, _menhir_s, annot, _, _endpos_annot_) = _menhir_stack in
      let (_startpos_value_, value) = (_startpos, _v) in
      let _v = _menhir_action_36 _endpos_annot_ _startpos_value_ annot value in
      _menhir_goto_prop_or_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_091 : type  ttv_stack. (ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ -> _ -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok ->
      let MenhirCell0_EQ (_menhir_stack, _startpos__eq_, _endpos__eq_) = _menhir_stack in
      let MenhirCell1_name (_menhir_stack, _menhir_s, key, _, _endpos_key_) = _menhir_stack in
      let (_startpos_value_, value, _eq) = (_startpos, _v, ()) in
      let _v = _menhir_action_35 _endpos__eq_ _endpos_key_ _eq _startpos__eq_ _startpos_value_ key value in
      _menhir_goto_prop_or_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_093 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ, _menhir_box_document) _menhir_cell1_type_annot -> _ -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _tok ->
      let MenhirCell1_type_annot (_menhir_stack, _, annot, _startpos_annot_, _endpos_annot_) = _menhir_stack in
      let MenhirCell0_EQ (_menhir_stack, _startpos__eq_, _endpos__eq_) = _menhir_stack in
      let MenhirCell1_name (_menhir_stack, _menhir_s, key, _, _endpos_key_) = _menhir_stack in
      let (_startpos_value_, value, _eq) = (_startpos, _v, ()) in
      let _v = _menhir_action_34 _endpos__eq_ _endpos_annot_ _endpos_key_ _eq _startpos__eq_ _startpos_annot_ _startpos_value_ annot key value in
      _menhir_goto_prop_or_arg _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_084 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_str_, str) = (_startpos, _v) in
      let _v = _menhir_action_46 str in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_str_ _v _menhir_s _tok
  
  and _menhir_run_085 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_str_, str) = (_startpos, _v) in
      let _v = _menhir_action_47 str in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_str_ _v _menhir_s _tok
  
  and _menhir_run_092 : type  ttv_stack. ((ttv_stack, _menhir_box_document) _menhir_cell1_name _menhir_cell0_EQ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_type_annot (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
      | STRING _v_0 ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState092
      | RAW_STRING _v_1 ->
          _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState092
      | NULL ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
      | INTEGER _v_2 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState092
      | IDENT _v_3 ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState092
      | FLOAT _v_4 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState092
      | FALSE ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
      | _ ->
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState092
  
  and _menhir_run_042 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_LPAREN -> _ -> _ -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RPAREN ->
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__3_, typ) = (_endpos_1, _v) in
          let _v = _menhir_action_38 typ in
          _menhir_goto_type_annot _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let MenhirCell1_LPAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__x_, _startpos__x_, _x) = (_endpos_3, _startpos_2, ()) in
          let _v = _menhir_action_39 _endpos__x_ _startpos__x_ _x in
          _menhir_error_goto_type_annot _menhir_stack _menhir_lexbuf _endpos__x_ _startpos__1_ _v _menhir_s
  
  and _menhir_run_047 : type  ttv_stack. ((((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_DISABLE, _menhir_box_document) _menhir_cell1_option_type_annot_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_name (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | STRING _v_0 ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState047
      | RAW_STRING _v_1 ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState047
      | NULL ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | LBRACE ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | INTEGER _v_2 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState047
      | IDENT _v_3 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState047
      | FLOAT _v_4 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState047
      | FALSE ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | DISABLE ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState047
      | EOF | NEWLINE | RBRACE | SEMI ->
          let _ = _menhir_action_11 () in
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState047
  
  and _menhir_run_073 : type  ttv_stack. (((ttv_stack, _menhir_box_document) _menhir_cell1_list_NEWLINE_, _menhir_box_document) _menhir_cell1_option_type_annot_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_name (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TRUE ->
          _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | STRING _v_0 ->
          _menhir_run_050 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState073
      | RAW_STRING _v_1 ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState073
      | NULL ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | LPAREN ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | LBRACE ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | INTEGER _v_2 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState073
      | IDENT _v_3 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState073
      | FLOAT _v_4 ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState073
      | FALSE ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | DISABLE ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | EOF | NEWLINE | RBRACE | SEMI ->
          let _v_5 = _menhir_action_11 () in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 _tok
      | _ ->
          _menhir_error_run_048 _menhir_stack _menhir_lexbuf MenhirState073
  
  and _menhir_run_089 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_document) _menhir_state -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_name (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | EQ ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_EQ (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState090 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TRUE ->
              _menhir_run_049 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | STRING _v ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | RAW_STRING _v ->
              _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | NULL ->
              _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LPAREN ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTEGER _v ->
              _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FLOAT _v ->
              _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FALSE ->
              _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _menhir_error_run_048 _menhir_stack _menhir_lexbuf _menhir_s)
      | _ ->
          _eRR ()
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_document =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NEWLINE ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | DISABLE | EOF | EQ | FALSE | FLOAT _ | IDENT _ | INTEGER _ | LPAREN | NULL | RAW_STRING _ | RPAREN | STRING _ | TRUE ->
          let _v = _menhir_action_09 () in
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v MenhirState000 _tok
      | _ ->
          _eRR ()
  
end

let document =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_document v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v