parser.ml — Coverage report


module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | VEC
    | VARIANT
    | TYPE
    | TEXT of (
# 60 "idllib/parser.mly"
      (string)
# 18 "idllib/parser.ml"
  )
    | SERVICE
    | SEMICOLON
    | RPAR
    | RECORD
    | RCURLY
    | QUERY
    | PRINCIPAL
    | PERIOD
    | OPT
    | ONEWAY
    | NOTEQ
    | NOTCOLON
    | NAT of (
# 58 "idllib/parser.mly"
      (string)
# 35 "idllib/parser.ml"
  )
    | MINUS
    | LPAR
    | LCURLY
    | IMPORT
    | ID of (
# 59 "idllib/parser.mly"
      (string)
# 44 "idllib/parser.ml"
  )
    | FUNC
    | EQQ
    | EQ
    | EOF
    | COMPOSITE_QUERY
    | COMMA
    | COLON
    | BLOB
    | ARROW
  
end

include MenhirBasics

# 1 "idllib/parser.mly"
  

open Syntax
open Source

module Uint32 = Lib.Uint32

(* Position handling *)

let position_to_pos position =
  (* TBR: Remove assertion once the menhir bug is fixed. *)
  assert (Obj.is_block (Obj.repr position));
  { file = position.Lexing.pos_fname;
    line = position.Lexing.pos_lnum;
    column = position.Lexing.pos_cnum - position.Lexing.pos_bol
  }

let positions_to_region position1 position2 =
  { left = position_to_pos position1;
    right = position_to_pos position2
  }

let at (startpos, endpos) = positions_to_region startpos endpos

let _anon sort at = "anon-" ^ sort ^ "-" ^ string_of_pos at.left

let prim_typs = ["nat", Nat; "nat8", Nat8; "nat16", Nat16; "nat32", Nat32; "nat64", Nat64;
                 "int", Int; "int8", Int8; "int16", Int16; "int32", Int32; "int64", Int64;
                 "float32", Float32; "float64", Float64; "bool", Bool; "text", Text;
                 "null", Null; "reserved", Reserved; "empty", Empty]
let is_prim_typs t = List.assoc_opt t prim_typs

let hash = IdlHash.idl_hash
let record_fields get_label fs =
  let open Uint32 in
  let rec go start fs =
    match fs with
    | [] -> []
    | hd :: tl ->
       let field = hd start in
       let next =
         (match (get_label field.it).it with
         | Id n -> succ n
         | Named name -> succ (hash name)
         | Unnamed n -> succ n) in
       field :: (go next tl)
  in go zero fs

# 109 "idllib/parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState001 : ('s _menhir_cell0_LPAR, _menhir_box_parse_args) _menhir_state
    (** State 001.
        Stack shape : LPAR.
        Start symbol: parse_args. *)

  | MenhirState003 : (('s, _menhir_box_parse_args) _menhir_cell1_VEC _menhir_cell0_LCURLY, _menhir_box_parse_args) _menhir_state
    (** State 003.
        Stack shape : VEC LCURLY.
        Start symbol: parse_args. *)

  | MenhirState007 : (('s, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_TEXT, _menhir_box_parse_args) _menhir_state
    (** State 007.
        Stack shape : VARIANT LCURLY TEXT.
        Start symbol: parse_args. *)

  | MenhirState013 : (('s, _menhir_box_parse_args) _menhir_cell1_RECORD _menhir_cell0_LCURLY, _menhir_box_parse_args) _menhir_state
    (** State 013.
        Stack shape : RECORD LCURLY.
        Start symbol: parse_args. *)

  | MenhirState015 : (('s, _menhir_box_parse_args) _menhir_cell1_TEXT, _menhir_box_parse_args) _menhir_state
    (** State 015.
        Stack shape : TEXT.
        Start symbol: parse_args. *)

  | MenhirState019 : (('s, _menhir_box_parse_args) _menhir_cell1_OPT, _menhir_box_parse_args) _menhir_state
    (** State 019.
        Stack shape : OPT.
        Start symbol: parse_args. *)

  | MenhirState021 : (('s, _menhir_box_parse_args) _menhir_cell1_NAT _menhir_cell0_PERIOD, _menhir_box_parse_args) _menhir_state
    (** State 021.
        Stack shape : NAT PERIOD.
        Start symbol: parse_args. *)

  | MenhirState023 : (('s, _menhir_box_parse_args) _menhir_cell1_MINUS, _menhir_box_parse_args) _menhir_state
    (** State 023.
        Stack shape : MINUS.
        Start symbol: parse_args. *)

  | MenhirState042 : (('s, _menhir_box_parse_args) _menhir_cell1_NAT, _menhir_box_parse_args) _menhir_state
    (** State 042.
        Stack shape : NAT.
        Start symbol: parse_args. *)

  | MenhirState045 : (('s, _menhir_box_parse_args) _menhir_cell1_ID, _menhir_box_parse_args) _menhir_state
    (** State 045.
        Stack shape : ID.
        Start symbol: parse_args. *)

  | MenhirState051 : (('s, _menhir_box_parse_args) _menhir_cell1_field_value _menhir_cell0_SEMICOLON, _menhir_box_parse_args) _menhir_state
    (** State 051.
        Stack shape : field_value SEMICOLON.
        Start symbol: parse_args. *)

  | MenhirState055 : (('s, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_NAT, _menhir_box_parse_args) _menhir_state
    (** State 055.
        Stack shape : VARIANT LCURLY NAT.
        Start symbol: parse_args. *)

  | MenhirState058 : (('s, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_ID, _menhir_box_parse_args) _menhir_state
    (** State 058.
        Stack shape : VARIANT LCURLY ID.
        Start symbol: parse_args. *)

  | MenhirState063 : (('s, _menhir_box_parse_args) _menhir_cell1_value _menhir_cell0_SEMICOLON, _menhir_box_parse_args) _menhir_state
    (** State 063.
        Stack shape : value SEMICOLON.
        Start symbol: parse_args. *)

  | MenhirState072 : (('s, _menhir_box_parse_args) _menhir_cell1_annval, _menhir_box_parse_args) _menhir_state
    (** State 072.
        Stack shape : annval.
        Start symbol: parse_args. *)

  | MenhirState075 : ('s, _menhir_box_parse_prog) _menhir_state
    (** State 075.
        Stack shape : .
        Start symbol: parse_prog. *)

  | MenhirState078 : (('s, 'r) _menhir_cell1_TYPE _menhir_cell0_ID, 'r) _menhir_state
    (** State 078.
        Stack shape : TYPE ID.
        Start symbol: <undetermined>. *)

  | MenhirState079 : (('s, 'r) _menhir_cell1_VEC, 'r) _menhir_state
    (** State 079.
        Stack shape : VEC.
        Start symbol: <undetermined>. *)

  | MenhirState081 : (('s, 'r) _menhir_cell1_VARIANT _menhir_cell0_LCURLY, 'r) _menhir_state
    (** State 081.
        Stack shape : VARIANT LCURLY.
        Start symbol: <undetermined>. *)

  | MenhirState083 : (('s, 'r) _menhir_cell1_TEXT, 'r) _menhir_state
    (** State 083.
        Stack shape : TEXT.
        Start symbol: <undetermined>. *)

  | MenhirState084 : (('s, 'r) _menhir_cell1_SERVICE, 'r) _menhir_state
    (** State 084.
        Stack shape : SERVICE.
        Start symbol: <undetermined>. *)

  | MenhirState085 : (('s, 'r) _menhir_cell1_LCURLY, 'r) _menhir_state
    (** State 085.
        Stack shape : LCURLY.
        Start symbol: <undetermined>. *)

  | MenhirState087 : (('s, 'r) _menhir_cell1_TEXT, 'r) _menhir_state
    (** State 087.
        Stack shape : TEXT.
        Start symbol: <undetermined>. *)

  | MenhirState088 : (('s, 'r) _menhir_cell1_LPAR, 'r) _menhir_state
    (** State 088.
        Stack shape : LPAR.
        Start symbol: <undetermined>. *)

  | MenhirState090 : (('s, 'r) _menhir_cell1_TEXT, 'r) _menhir_state
    (** State 090.
        Stack shape : TEXT.
        Start symbol: <undetermined>. *)

  | MenhirState092 : (('s, 'r) _menhir_cell1_RECORD _menhir_cell0_LCURLY, 'r) _menhir_state
    (** State 092.
        Stack shape : RECORD LCURLY.
        Start symbol: <undetermined>. *)

  | MenhirState095 : (('s, 'r) _menhir_cell1_OPT, 'r) _menhir_state
    (** State 095.
        Stack shape : OPT.
        Start symbol: <undetermined>. *)

  | MenhirState097 : (('s, 'r) _menhir_cell1_FUNC, 'r) _menhir_state
    (** State 097.
        Stack shape : FUNC.
        Start symbol: <undetermined>. *)

  | MenhirState099 : (('s, 'r) _menhir_cell1_param_typs, 'r) _menhir_state
    (** State 099.
        Stack shape : param_typs.
        Start symbol: <undetermined>. *)

  | MenhirState100 : ((('s, 'r) _menhir_cell1_param_typs, 'r) _menhir_cell1_param_typs, 'r) _menhir_state
    (** State 100.
        Stack shape : param_typs param_typs.
        Start symbol: <undetermined>. *)

  | MenhirState105 : (('s, 'r) _menhir_cell1_func_mode, 'r) _menhir_state
    (** State 105.
        Stack shape : func_mode.
        Start symbol: <undetermined>. *)

  | MenhirState114 : (('s, 'r) _menhir_cell1_NAT, 'r) _menhir_state
    (** State 114.
        Stack shape : NAT.
        Start symbol: <undetermined>. *)

  | MenhirState117 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 117.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState122 : (('s, 'r) _menhir_cell1_record_typ _menhir_cell0_SEMICOLON, 'r) _menhir_state
    (** State 122.
        Stack shape : record_typ SEMICOLON.
        Start symbol: <undetermined>. *)

  | MenhirState129 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 129.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

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

  | MenhirState140 : (('s, 'r) _menhir_cell1_ID, 'r) _menhir_state
    (** State 140.
        Stack shape : ID.
        Start symbol: <undetermined>. *)

  | MenhirState146 : (('s, 'r) _menhir_cell1_meth_typ _menhir_cell0_SEMICOLON, 'r) _menhir_state
    (** State 146.
        Stack shape : meth_typ SEMICOLON.
        Start symbol: <undetermined>. *)

  | MenhirState153 : (('s, 'r) _menhir_cell1_variant_typ _menhir_cell0_SEMICOLON, 'r) _menhir_state
    (** State 153.
        Stack shape : variant_typ SEMICOLON.
        Start symbol: <undetermined>. *)

  | MenhirState167 : (('s, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_state
    (** State 167.
        Stack shape : seplist(def,SEMICOLON) SERVICE id_opt.
        Start symbol: parse_prog. *)

  | MenhirState168 : ((('s, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_ID, _menhir_box_parse_prog) _menhir_state
    (** State 168.
        Stack shape : seplist(def,SEMICOLON) SERVICE id_opt ID.
        Start symbol: parse_prog. *)

  | MenhirState172 : ((('s, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_param_typs, _menhir_box_parse_prog) _menhir_state
    (** State 172.
        Stack shape : seplist(def,SEMICOLON) SERVICE id_opt param_typs.
        Start symbol: parse_prog. *)

  | MenhirState175 : ((('s, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_actor_typ, _menhir_box_parse_prog) _menhir_state
    (** State 175.
        Stack shape : seplist(def,SEMICOLON) SERVICE id_opt actor_typ.
        Start symbol: parse_prog. *)

  | MenhirState177 : ((('s, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_actor_class_typ, _menhir_box_parse_prog) _menhir_state
    (** State 177.
        Stack shape : seplist(def,SEMICOLON) SERVICE id_opt actor_class_typ.
        Start symbol: parse_prog. *)

  | MenhirState183 : (('s, 'r) _menhir_cell1_def _menhir_cell0_SEMICOLON, 'r) _menhir_state
    (** State 183.
        Stack shape : def SEMICOLON.
        Start symbol: <undetermined>. *)

  | MenhirState185 : ('s, _menhir_box_parse_tests) _menhir_state
    (** State 185.
        Stack shape : .
        Start symbol: parse_tests. *)

  | MenhirState187 : (('s, _menhir_box_parse_tests) _menhir_cell1_endlist_def_SEMICOLON_, _menhir_box_parse_tests) _menhir_state
    (** State 187.
        Stack shape : endlist(def,SEMICOLON).
        Start symbol: parse_tests. *)

  | MenhirState188 : (('s, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_state
    (** State 188.
        Stack shape : ID.
        Start symbol: parse_tests. *)

  | MenhirState193 : ((('s, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_input, _menhir_box_parse_tests) _menhir_state
    (** State 193.
        Stack shape : ID input.
        Start symbol: parse_tests. *)

  | MenhirState197 : ((('s, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_input, _menhir_box_parse_tests) _menhir_state
    (** State 197.
        Stack shape : ID input.
        Start symbol: parse_tests. *)

  | MenhirState201 : ((('s, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_assertion, _menhir_box_parse_tests) _menhir_state
    (** State 201.
        Stack shape : ID assertion.
        Start symbol: parse_tests. *)

  | MenhirState206 : (('s, _menhir_box_parse_tests) _menhir_cell1_test _menhir_cell0_SEMICOLON, _menhir_box_parse_tests) _menhir_state
    (** State 206.
        Stack shape : test SEMICOLON.
        Start symbol: parse_tests. *)

  | MenhirState211 : (('s, _menhir_box_parse_tests) _menhir_cell1_def _menhir_cell0_SEMICOLON, _menhir_box_parse_tests) _menhir_state
    (** State 211.
        Stack shape : def SEMICOLON.
        Start symbol: parse_tests. *)


and ('s, 'r) _menhir_cell1_actor_class_typ = 
  | MenhirCell1_actor_class_typ of 's * ('s, 'r) _menhir_state * (Syntax.typ' Source.phrase)

and ('s, 'r) _menhir_cell1_actor_typ = 
  | MenhirCell1_actor_typ of 's * ('s, 'r) _menhir_state * (Syntax.typ_meth list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_annval = 
  | MenhirCell1_annval of 's * ('s, 'r) _menhir_state * (Syntax.value)

and ('s, 'r) _menhir_cell1_assertion = 
  | MenhirCell1_assertion of 's * ('s, 'r) _menhir_state * (Syntax.test_assertion)

and ('s, 'r) _menhir_cell1_def = 
  | MenhirCell1_def of 's * ('s, 'r) _menhir_state * (Syntax.dec) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_endlist_def_SEMICOLON_ = 
  | MenhirCell1_endlist_def_SEMICOLON_ of 's * ('s, 'r) _menhir_state * (Syntax.dec list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_field_value = 
  | MenhirCell1_field_value of 's * ('s, 'r) _menhir_state * (Uint32.t -> Syntax.field_value)

and ('s, 'r) _menhir_cell1_func_mode = 
  | MenhirCell1_func_mode of 's * ('s, 'r) _menhir_state * (Syntax.func_mode)

and 's _menhir_cell0_id_opt = 
  | MenhirCell0_id_opt of 's * (unit)

and ('s, 'r) _menhir_cell1_input = 
  | MenhirCell1_input of 's * ('s, 'r) _menhir_state * (Syntax.input)

and ('s, 'r) _menhir_cell1_meth_typ = 
  | MenhirCell1_meth_typ of 's * ('s, 'r) _menhir_state * (Syntax.typ_meth' Source.phrase)

and ('s, 'r) _menhir_cell1_param_typ = 
  | MenhirCell1_param_typ of 's * ('s, 'r) _menhir_state * (Syntax.typ)

and ('s, 'r) _menhir_cell1_param_typs = 
  | MenhirCell1_param_typs of 's * ('s, 'r) _menhir_state * (Syntax.typ list) * Lexing.position

and ('s, 'r) _menhir_cell1_record_typ = 
  | MenhirCell1_record_typ of 's * ('s, 'r) _menhir_state * (Uint32.t -> Syntax.typ_field' Source.phrase)

and ('s, 'r) _menhir_cell1_seplist_def_SEMICOLON_ = 
  | MenhirCell1_seplist_def_SEMICOLON_ of 's * ('s, 'r) _menhir_state * (Syntax.dec list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_test = 
  | MenhirCell1_test of 's * ('s, 'r) _menhir_state * (Syntax.test' Source.phrase) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_value = 
  | MenhirCell1_value of 's * ('s, 'r) _menhir_state * (Syntax.value' Source.phrase) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_variant_typ = 
  | MenhirCell1_variant_typ of 's * ('s, 'r) _menhir_state * (Syntax.typ_field' Source.phrase)

and ('s, 'r) _menhir_cell1_FUNC = 
  | MenhirCell1_FUNC of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_ID = 
  | MenhirCell1_ID of 's * ('s, 'r) _menhir_state * (
# 59 "idllib/parser.mly"
      (string)
# 439 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_ID = 
  | MenhirCell0_ID of 's * (
# 59 "idllib/parser.mly"
      (string)
# 446 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_LCURLY = 
  | MenhirCell1_LCURLY of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_LCURLY = 
  | MenhirCell0_LCURLY of 's * Lexing.position

and ('s, 'r) _menhir_cell1_LPAR = 
  | MenhirCell1_LPAR of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_LPAR = 
  | MenhirCell0_LPAR of 's * Lexing.position

and ('s, 'r) _menhir_cell1_MINUS = 
  | MenhirCell1_MINUS of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_NAT = 
  | MenhirCell1_NAT of 's * ('s, 'r) _menhir_state * (
# 58 "idllib/parser.mly"
      (string)
# 468 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_NAT = 
  | MenhirCell0_NAT of 's * (
# 58 "idllib/parser.mly"
      (string)
# 475 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_OPT = 
  | MenhirCell1_OPT of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_PERIOD = 
  | MenhirCell0_PERIOD of 's * Lexing.position

and ('s, 'r) _menhir_cell1_RECORD = 
  | MenhirCell1_RECORD of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_SEMICOLON = 
  | MenhirCell0_SEMICOLON of 's * Lexing.position

and ('s, 'r) _menhir_cell1_SERVICE = 
  | MenhirCell1_SERVICE of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_SERVICE = 
  | MenhirCell0_SERVICE of 's * Lexing.position

and ('s, 'r) _menhir_cell1_TEXT = 
  | MenhirCell1_TEXT of 's * ('s, 'r) _menhir_state * (
# 60 "idllib/parser.mly"
      (string)
# 500 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_TEXT = 
  | MenhirCell0_TEXT of 's * (
# 60 "idllib/parser.mly"
      (string)
# 507 "idllib/parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_TYPE = 
  | MenhirCell1_TYPE of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_VARIANT = 
  | MenhirCell1_VARIANT of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_VEC = 
  | MenhirCell1_VEC of 's * ('s, 'r) _menhir_state * Lexing.position

and _menhir_box_parse_tests = 
  | MenhirBox_parse_tests of (string -> Syntax.tests) [@@unboxed]

and _menhir_box_parse_prog = 
  | MenhirBox_parse_prog of (string -> Syntax.prog) [@@unboxed]

and _menhir_box_parse_args = 
  | MenhirBox_parse_args of (Syntax.value list Source.phrase) [@@unboxed]

let _menhir_action_003 =
  fun () ->
    (
# 195 "idllib/parser.mly"
                ( None )
# 533 "idllib/parser.ml"
     : (Syntax.typ option))

let _menhir_action_004 =
  fun _endpos_tys_ _startpos_tys_ tys ->
    let _loc_tys_ = (_startpos_tys_, _endpos_tys_) in
    (
# 197 "idllib/parser.mly"
    ( Some (ServT tys @@ at _loc_tys_) )
# 542 "idllib/parser.ml"
     : (Syntax.typ option))

let _menhir_action_005 =
  fun _endpos_id_ _startpos_id_ id ->
    let x =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 554 "idllib/parser.ml"
      
    in
    (
# 199 "idllib/parser.mly"
    ( Some (VarT x @@ x.at) )
# 560 "idllib/parser.ml"
     : (Syntax.typ option))

let _menhir_action_006 =
  fun t ->
    (
# 201 "idllib/parser.mly"
    ( Some t )
# 568 "idllib/parser.ml"
     : (Syntax.typ option))

let _menhir_action_007 =
  fun _endpos_tys_ _startpos_args_ _startpos_tys_ args tys ->
    let _endpos = _endpos_tys_ in
    let _symbolstartpos = _startpos_args_ in
    let _loc_tys_ = (_startpos_tys_, _endpos_tys_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 190 "idllib/parser.mly"
    ( ClassT (args, ServT tys @@ at _loc_tys_) @@ at _sloc )
# 580 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_008 =
  fun _endpos_id_ _startpos_args_ _startpos_id_ args id ->
    let x =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 592 "idllib/parser.ml"
      
    in
    let _endpos_x_ = _endpos_id_ in
    let _endpos = _endpos_x_ in
    let _symbolstartpos = _startpos_args_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 192 "idllib/parser.mly"
    ( ClassT (args, VarT x @@ x.at) @@ at _sloc )
# 602 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_009 =
  fun ds ->
    (
# 173 "idllib/parser.mly"
    ( ds )
# 610 "idllib/parser.ml"
     : (Syntax.typ_meth list))

let _menhir_action_010 =
  fun v ->
    (
# 265 "idllib/parser.mly"
            ( v )
# 618 "idllib/parser.ml"
     : (Syntax.value))

let _menhir_action_011 =
  fun input ->
    (
# 278 "idllib/parser.mly"
                         ( ParsesAs (true,  input) )
# 626 "idllib/parser.ml"
     : (Syntax.test_assertion))

let _menhir_action_012 =
  fun input ->
    (
# 279 "idllib/parser.mly"
                         ( ParsesAs (false, input) )
# 634 "idllib/parser.ml"
     : (Syntax.test_assertion))

let _menhir_action_013 =
  fun i1 i2 ->
    (
# 280 "idllib/parser.mly"
                                  ( ParsesEqual (true,  i1, i2) )
# 642 "idllib/parser.ml"
     : (Syntax.test_assertion))

let _menhir_action_014 =
  fun i1 i2 ->
    (
# 281 "idllib/parser.mly"
                                  ( ParsesEqual (false, i1, i2) )
# 650 "idllib/parser.ml"
     : (Syntax.test_assertion))

let _menhir_action_015 =
  fun _endpos_t_ _startpos__1_ t ->
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 133 "idllib/parser.mly"
                   ( OptT t @@ at _sloc )
# 661 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_016 =
  fun _endpos_t_ _startpos__1_ t ->
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 134 "idllib/parser.mly"
                   ( VecT t @@ at _sloc )
# 672 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_017 =
  fun _endpos_fs_ _startpos__1_ fs ->
    let _endpos = _endpos_fs_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 135 "idllib/parser.mly"
                          ( RecordT fs @@ at _sloc )
# 683 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_018 =
  fun _endpos_fs_ _startpos__1_ fs ->
    let _endpos = _endpos_fs_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 136 "idllib/parser.mly"
                            ( VariantT fs @@ at _sloc )
# 694 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_019 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 137 "idllib/parser.mly"
         ( BlobT @@ at _sloc )
# 705 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_020 =
  fun t ->
    (
# 140 "idllib/parser.mly"
               ( t )
# 713 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_021 =
  fun t ->
    (
# 141 "idllib/parser.mly"
              ( t )
# 721 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_022 =
  fun t ->
    (
# 142 "idllib/parser.mly"
               ( t )
# 729 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_023 =
  fun _endpos_id_ _endpos_t_ _startpos__1_ _startpos_id_ id t ->
    let x =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 741 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 179 "idllib/parser.mly"
    ( TypD(x, t) @@ at _sloc )
# 750 "idllib/parser.ml"
     : (Syntax.dec))

let _menhir_action_024 =
  fun _endpos_s_ _startpos__1_ _startpos_s_ s ->
    let file =
      let _endpos = _endpos_s_ in
      let _symbolstartpos = _startpos_s_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 764 "idllib/parser.ml"
      
    in
    let _endpos_file_ = _endpos_s_ in
    let _endpos = _endpos_file_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 182 "idllib/parser.mly"
    ( ImportD (file, ref "") @@ at _sloc )
# 774 "idllib/parser.ml"
     : (Syntax.dec))

let _menhir_action_025 =
  fun () ->
    (
# 71 "idllib/parser.mly"
                ( [] )
# 782 "idllib/parser.ml"
     : (Syntax.dec list))

let _menhir_action_026 =
  fun x xs ->
    (
# 72 "idllib/parser.mly"
                               ( x::xs )
# 790 "idllib/parser.ml"
     : (Syntax.dec list))

let _menhir_action_027 =
  fun _endpos_n_ _endpos_t_ _startpos_n_ n t ->
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_n_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 109 "idllib/parser.mly"
    ( { label = Id (Uint32.of_string n) @@ at _loc_n_; typ = t } @@ at _sloc )
# 802 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_028 =
  fun _endpos_id_ _endpos_t_ _startpos_id_ id t ->
    let name =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 814 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 111 "idllib/parser.mly"
    ( { label = Named name.it @@ at _loc_name_; typ = t } @@ at _sloc )
# 825 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_029 =
  fun _endpos_s_ _endpos_t_ _startpos_s_ s t ->
    let name =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 840 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 850 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_s_, _startpos_s_) in
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 111 "idllib/parser.mly"
    ( { label = Named name.it @@ at _loc_name_; typ = t } @@ at _sloc )
# 861 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_030 =
  fun _endpos_n_ _endpos_v_ _startpos_n_ n v ->
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_n_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 258 "idllib/parser.mly"
    ( fun _ -> (Id (Uint32.of_string n) @@ at _loc_n_, v) @@ at _sloc )
# 873 "idllib/parser.ml"
     : (Uint32.t -> Syntax.field_value))

let _menhir_action_031 =
  fun _endpos_id_ _endpos_v_ _startpos_id_ id v ->
    let name =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 885 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 260 "idllib/parser.mly"
    ( fun _ -> (Named name.it @@ at _loc_name_, v) @@ at _sloc )
# 896 "idllib/parser.ml"
     : (Uint32.t -> Syntax.field_value))

let _menhir_action_032 =
  fun _endpos_s_ _endpos_v_ _startpos_s_ s v ->
    let name =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 911 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 921 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_s_, _startpos_s_) in
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 260 "idllib/parser.mly"
    ( fun _ -> (Named name.it @@ at _loc_name_, v) @@ at _sloc )
# 932 "idllib/parser.ml"
     : (Uint32.t -> Syntax.field_value))

let _menhir_action_033 =
  fun _endpos_v_ _startpos_v_ v ->
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_v_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 262 "idllib/parser.mly"
    ( fun n -> (Unnamed n @@ no_region, v) @@ at _sloc )
# 943 "idllib/parser.ml"
     : (Uint32.t -> Syntax.field_value))

let _menhir_action_034 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 153 "idllib/parser.mly"
           ( Oneway @@ at _sloc )
# 954 "idllib/parser.ml"
     : (Syntax.func_mode))

let _menhir_action_035 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 154 "idllib/parser.mly"
          ( Query @@ at _sloc )
# 965 "idllib/parser.ml"
     : (Syntax.func_mode))

let _menhir_action_036 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 155 "idllib/parser.mly"
                    ( Composite @@ at _sloc )
# 976 "idllib/parser.ml"
     : (Syntax.func_mode))

let _menhir_action_037 =
  fun () ->
    (
# 158 "idllib/parser.mly"
                ( [] )
# 984 "idllib/parser.ml"
     : (Syntax.func_mode list))

let _menhir_action_038 =
  fun m ms ->
    (
# 159 "idllib/parser.mly"
                                  ( m::ms )
# 992 "idllib/parser.ml"
     : (Syntax.func_mode list))

let _menhir_action_039 =
  fun _endpos_ms_ _startpos_t1_ ms t1 t2 ->
    let _endpos = _endpos_ms_ in
    let _symbolstartpos = _startpos_t1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 163 "idllib/parser.mly"
    ( FuncT(ms, t1, t2) @@ at _sloc )
# 1003 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_040 =
  fun () ->
    (
# 185 "idllib/parser.mly"
                ( )
# 1011 "idllib/parser.ml"
     : (unit))

let _menhir_action_041 =
  fun _endpos_id_ _startpos_id_ id ->
    let _1 =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1023 "idllib/parser.ml"
      
    in
    (
# 186 "idllib/parser.mly"
       ( )
# 1029 "idllib/parser.ml"
     : (unit))

let _menhir_action_042 =
  fun _endpos_s_ _startpos_s_ s ->
    let text =
      let _endpos = _endpos_s_ in
      let _symbolstartpos = _startpos_s_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1043 "idllib/parser.ml"
      
    in
    (
# 274 "idllib/parser.mly"
              ( TextualInput text )
# 1049 "idllib/parser.ml"
     : (Syntax.input))

let _menhir_action_043 =
  fun text ->
    (
# 275 "idllib/parser.mly"
                   ( BinaryInput text )
# 1057 "idllib/parser.ml"
     : (Syntax.input))

let _menhir_action_044 =
  fun _endpos_id_ _endpos_t_ _startpos_id_ id t ->
    let x =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1069 "idllib/parser.ml"
      
    in
    let _startpos_x_ = _startpos_id_ in
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 167 "idllib/parser.mly"
    ( { var = x; meth = t } @@ at _sloc )
# 1079 "idllib/parser.ml"
     : (Syntax.typ_meth' Source.phrase))

let _menhir_action_045 =
  fun _endpos_s_ _endpos_t_ _startpos_s_ s t ->
    let x =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1094 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1104 "idllib/parser.ml"
      
    in
    let _startpos_x_ = _startpos_s_ in
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 167 "idllib/parser.mly"
    ( { var = x; meth = t } @@ at _sloc )
# 1114 "idllib/parser.ml"
     : (Syntax.typ_meth' Source.phrase))

let _menhir_action_046 =
  fun _endpos_id_ _endpos_id_inlined1_ _startpos_id_ _startpos_id_inlined1_ id id_inlined1 ->
    let id =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1126 "idllib/parser.ml"
      
    in
    let x =
      let (_endpos_id_, _startpos_id_, id) = (_endpos_id_inlined1_, _startpos_id_inlined1_, id_inlined1) in
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1137 "idllib/parser.ml"
      
    in
    let _startpos_x_ = _startpos_id_inlined1_ in
    let _endpos = _endpos_id_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 169 "idllib/parser.mly"
    ( { var = x; meth = VarT id @@ at _sloc } @@ at _sloc )
# 1147 "idllib/parser.ml"
     : (Syntax.typ_meth' Source.phrase))

let _menhir_action_047 =
  fun _endpos_id_ _endpos_s_ _startpos_id_ _startpos_s_ id s ->
    let id =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1159 "idllib/parser.ml"
      
    in
    let x =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1172 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1182 "idllib/parser.ml"
      
    in
    let _startpos_x_ = _startpos_s_ in
    let _endpos = _endpos_id_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 169 "idllib/parser.mly"
    ( { var = x; meth = VarT id @@ at _sloc } @@ at _sloc )
# 1192 "idllib/parser.ml"
     : (Syntax.typ_meth' Source.phrase))

let _menhir_action_048 =
  fun n n2 ->
    (
# 216 "idllib/parser.mly"
                        ( n ^ "." ^ n2 )
# 1200 "idllib/parser.ml"
     : (string))

let _menhir_action_049 =
  fun n ->
    (
# 217 "idllib/parser.mly"
                 ( n ^ "." )
# 1208 "idllib/parser.ml"
     : (string))

let _menhir_action_050 =
  fun n ->
    (
# 218 "idllib/parser.mly"
          ( n )
# 1216 "idllib/parser.ml"
     : (string))

let _menhir_action_051 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 1224 "idllib/parser.ml"
     : (unit option))

let _menhir_action_052 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 1232 "idllib/parser.ml"
     : (unit option))

let _menhir_action_053 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 1240 "idllib/parser.ml"
     : (string option))

let _menhir_action_054 =
  fun _endpos_s_ _startpos_s_ s ->
    let x =
      let _endpos = _endpos_s_ in
      let _symbolstartpos = _startpos_s_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1254 "idllib/parser.ml"
      
    in
    (
# 114 "<standard.mly>"
    ( Some x )
# 1260 "idllib/parser.ml"
     : (string option))

let _menhir_action_055 =
  fun t ->
    (
# 149 "idllib/parser.mly"
               ( t )
# 1268 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_056 =
  fun _endpos_id_ _startpos_id_ id t ->
    let _1 =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1280 "idllib/parser.ml"
      
    in
    (
# 150 "idllib/parser.mly"
                          ( t )
# 1286 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_057 =
  fun _endpos_s_ _startpos_s_ s t ->
    let _1 =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1301 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1311 "idllib/parser.ml"
      
    in
    (
# 150 "idllib/parser.mly"
                          ( t )
# 1317 "idllib/parser.ml"
     : (Syntax.typ))

let _menhir_action_058 =
  fun fs ->
    (
# 146 "idllib/parser.mly"
    ( fs )
# 1325 "idllib/parser.ml"
     : (Syntax.typ list))

let _menhir_action_059 =
  fun _endpos__4_ _startpos__1_ vs ->
    let _endpos = _endpos__4_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 268 "idllib/parser.mly"
                                            ( vs @@ at _sloc )
# 1336 "idllib/parser.ml"
     : (Syntax.value list Source.phrase))

let _menhir_action_060 =
  fun _endpos__3_ _endpos_actor_ _endpos_ds_ _startpos__3_ _startpos_actor_ _startpos_ds_ actor ds ->
    let _endpos = _endpos__3_ in
    let _symbolstartpos = if _startpos_ds_ != _endpos_ds_ then
      _startpos_ds_
    else
      if _startpos_actor_ != _endpos_actor_ then
        _startpos_actor_
      else
        _startpos__3_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 207 "idllib/parser.mly"
    (
      let trivia = Trivia.PosHashtbl.create 0 in
      fun filename -> {it = {decs=ds; actor=actor}; at = at _sloc; note = {filename; trivia}} )
# 1355 "idllib/parser.ml"
     : (string -> Syntax.prog))

let _menhir_action_061 =
  fun _endpos__3_ _endpos_tdecs_ _endpos_tests_ _startpos__3_ _startpos_tdecs_ _startpos_tests_ tdecs tests ->
    let _endpos = _endpos__3_ in
    let _symbolstartpos = if _startpos_tdecs_ != _endpos_tdecs_ then
      _startpos_tdecs_
    else
      if _startpos_tests_ != _endpos_tests_ then
        _startpos_tests_
      else
        _startpos__3_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 290 "idllib/parser.mly"
    ( fun filename -> {it = {tdecs; tests}; at = at _sloc; note = filename} )
# 1372 "idllib/parser.ml"
     : (string -> Syntax.tests))

let _menhir_action_062 =
  fun _endpos_id_ _startpos_id_ id ->
    let x =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1384 "idllib/parser.ml"
      
    in
    let (_endpos_x_, _startpos_x_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_x_ in
    let _symbolstartpos = _startpos_x_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 98 "idllib/parser.mly"
    ( (match is_prim_typs x.it with
         None -> VarT x
       | Some t -> PrimT t) @@ at _sloc )
# 1396 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_063 =
  fun f ->
    (
# 114 "idllib/parser.mly"
                ( fun _ -> f )
# 1404 "idllib/parser.ml"
     : (Uint32.t -> Syntax.typ_field' Source.phrase))

let _menhir_action_064 =
  fun _endpos_t_ _startpos_t_ t ->
    let _endpos = _endpos_t_ in
    let _symbolstartpos = _startpos_t_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 116 "idllib/parser.mly"
    ( fun x -> { label = Unnamed x @@ no_region; typ = t } @@ at _sloc )
# 1415 "idllib/parser.ml"
     : (Uint32.t -> Syntax.typ_field' Source.phrase))

let _menhir_action_065 =
  fun fs ->
    (
# 127 "idllib/parser.mly"
    ( record_fields (fun f -> f.label) fs )
# 1423 "idllib/parser.ml"
     : (Syntax.typ_field list))

let _menhir_action_066 =
  fun t ->
    (
# 103 "idllib/parser.mly"
                    ( t )
# 1431 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_067 =
  fun _endpos_ts_ _startpos__1_ ts ->
    let _endpos = _endpos_ts_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 104 "idllib/parser.mly"
                         ( ServT ts @@ at _sloc )
# 1442 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_068 =
  fun _endpos__1_ _startpos__1_ ->
    let _endpos = _endpos__1_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 105 "idllib/parser.mly"
              ( PrincipalT @@ at _sloc )
# 1453 "idllib/parser.ml"
     : (Syntax.typ' Source.phrase))

let _menhir_action_069 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1461 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_070 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1469 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_071 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1477 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_072 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1485 "idllib/parser.ml"
     : (Syntax.dec list))

let _menhir_action_073 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1493 "idllib/parser.ml"
     : (Syntax.dec list))

let _menhir_action_074 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1501 "idllib/parser.ml"
     : (Syntax.dec list))

let _menhir_action_075 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1509 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.field_value) list))

let _menhir_action_076 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1517 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.field_value) list))

let _menhir_action_077 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1525 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.field_value) list))

let _menhir_action_078 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1533 "idllib/parser.ml"
     : (Syntax.typ_meth list))

let _menhir_action_079 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1541 "idllib/parser.ml"
     : (Syntax.typ_meth list))

let _menhir_action_080 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1549 "idllib/parser.ml"
     : (Syntax.typ_meth list))

let _menhir_action_081 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1557 "idllib/parser.ml"
     : (Syntax.typ list))

let _menhir_action_082 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1565 "idllib/parser.ml"
     : (Syntax.typ list))

let _menhir_action_083 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1573 "idllib/parser.ml"
     : (Syntax.typ list))

let _menhir_action_084 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1581 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.typ_field' Source.phrase) list))

let _menhir_action_085 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1589 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.typ_field' Source.phrase) list))

let _menhir_action_086 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1597 "idllib/parser.ml"
     : ((Uint32.t -> Syntax.typ_field' Source.phrase) list))

let _menhir_action_087 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1605 "idllib/parser.ml"
     : (Syntax.test list))

let _menhir_action_088 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1613 "idllib/parser.ml"
     : (Syntax.test list))

let _menhir_action_089 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1621 "idllib/parser.ml"
     : (Syntax.test list))

let _menhir_action_090 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1629 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_091 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1637 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_092 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1645 "idllib/parser.ml"
     : (Syntax.value list))

let _menhir_action_093 =
  fun () ->
    (
# 75 "idllib/parser.mly"
                ( [] )
# 1653 "idllib/parser.ml"
     : (Syntax.typ_field list))

let _menhir_action_094 =
  fun x ->
    (
# 76 "idllib/parser.mly"
        ( [x] )
# 1661 "idllib/parser.ml"
     : (Syntax.typ_field list))

let _menhir_action_095 =
  fun x xs ->
    (
# 77 "idllib/parser.mly"
                               ( x::xs )
# 1669 "idllib/parser.ml"
     : (Syntax.typ_field list))

let _menhir_action_096 =
  fun n ->
    (
# 221 "idllib/parser.mly"
                ( "-" ^ n )
# 1677 "idllib/parser.ml"
     : (string))

let _menhir_action_097 =
  fun n ->
    (
# 222 "idllib/parser.mly"
          ( n )
# 1685 "idllib/parser.ml"
     : (string))

let _menhir_action_098 =
  fun _endpos_desc_ _endpos_id_ _startpos_id_ assertion desc id tys ->
    let id =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1697 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_desc_ in
    let _symbolstartpos = _startpos_id_ in
    let _loc_id_ = (_startpos_id_, _endpos_id_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 285 "idllib/parser.mly"
    ( if id.it <> "assert" then raise (ParseError (at _loc_id_, id.it))
      else { ttyp=tys; assertion; desc } @@ at _sloc )
# 1708 "idllib/parser.ml"
     : (Syntax.test' Source.phrase))

let _menhir_action_099 =
  fun _endpos_n_ _startpos_n_ n ->
    let _endpos = _endpos_n_ in
    let _symbolstartpos = _startpos_n_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 225 "idllib/parser.mly"
                 ( NumV n @@ at _sloc )
# 1719 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_100 =
  fun _endpos_v_ _startpos__1_ v ->
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 226 "idllib/parser.mly"
                ( OptV v @@ at _sloc )
# 1730 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_101 =
  fun _endpos__4_ _startpos__1_ vs ->
    let _endpos = _endpos__4_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 228 "idllib/parser.mly"
    ( VecV vs @@ at _sloc )
# 1741 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_102 =
  fun _endpos_text_ _startpos__1_ text ->
    let _endpos = _endpos_text_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 229 "idllib/parser.mly"
                   ( BlobV text @@ at _sloc )
# 1752 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_103 =
  fun _endpos_text_ _startpos_text_ text ->
    let _endpos = _endpos_text_ in
    let _symbolstartpos = _startpos_text_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 230 "idllib/parser.mly"
              ( TextV text @@ at _sloc )
# 1763 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_104 =
  fun _endpos__4_ _startpos__1_ fs ->
    let _endpos = _endpos__4_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 232 "idllib/parser.mly"
    ( RecordV (record_fields (fun f -> fst f) fs) @@ at _sloc )
# 1774 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_105 =
  fun _endpos__4_ _startpos__1_ f ->
    let _endpos = _endpos__4_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 234 "idllib/parser.mly"
    ( VariantV f @@ at _sloc )
# 1785 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_106 =
  fun _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let s =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1797 "idllib/parser.ml"
      
    in
    let _endpos_s_ = _endpos_id_ in
    let _endpos = _endpos_s_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 235 "idllib/parser.mly"
                   ( ServiceV s.it @@ at _sloc )
# 1807 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_107 =
  fun _endpos_s_ _startpos__1_ _startpos_s_ s ->
    let s =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1822 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1832 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_s_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 235 "idllib/parser.mly"
                   ( ServiceV s.it @@ at _sloc )
# 1841 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_108 =
  fun _endpos_id_ _endpos_id_inlined1_ _startpos__1_ _startpos_id_ _startpos_id_inlined1_ id id_inlined1 ->
    let m =
      let (_endpos_id_, _startpos_id_, id) = (_endpos_id_inlined1_, _startpos_id_inlined1_, id_inlined1) in
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1854 "idllib/parser.ml"
      
    in
    let _endpos_m_ = _endpos_id_inlined1_ in
    let s =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1865 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_m_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 236 "idllib/parser.mly"
                              ( FuncV (s.it, m.it) @@ at _sloc )
# 1874 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_109 =
  fun _endpos_id_ _endpos_s_ _startpos__1_ _startpos_id_ _startpos_s_ id s ->
    let m =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1889 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1899 "idllib/parser.ml"
      
    in
    let _endpos_m_ = _endpos_s_ in
    let s =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1910 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_m_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 236 "idllib/parser.mly"
                              ( FuncV (s.it, m.it) @@ at _sloc )
# 1919 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_110 =
  fun _endpos_id_ _endpos_s_ _startpos__1_ _startpos_id_ _startpos_s_ id s ->
    let m =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 1931 "idllib/parser.ml"
      
    in
    let _endpos_m_ = _endpos_id_ in
    let s =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1945 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1955 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_m_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 236 "idllib/parser.mly"
                              ( FuncV (s.it, m.it) @@ at _sloc )
# 1964 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_111 =
  fun _endpos_s_ _endpos_s_inlined1_ _startpos__1_ _startpos_s_ _startpos_s_inlined1_ s s_inlined1 ->
    let m =
      let (_endpos_s_, _startpos_s_, s) = (_endpos_s_inlined1_, _startpos_s_inlined1_, s_inlined1) in
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 1980 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 1990 "idllib/parser.ml"
      
    in
    let _endpos_m_ = _endpos_s_inlined1_ in
    let s =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 2004 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 2014 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_m_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 236 "idllib/parser.mly"
                              ( FuncV (s.it, m.it) @@ at _sloc )
# 2023 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_112 =
  fun _endpos_id_ _startpos__1_ _startpos_id_ id ->
    let s =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 2035 "idllib/parser.ml"
      
    in
    let _endpos_s_ = _endpos_id_ in
    let _endpos = _endpos_s_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 237 "idllib/parser.mly"
                     ( PrincipalV s.it @@ at _sloc )
# 2045 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_113 =
  fun _endpos_s_ _startpos__1_ _startpos_s_ s ->
    let s =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 2060 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 2070 "idllib/parser.ml"
      
    in
    let _endpos = _endpos_s_ in
    let _symbolstartpos = _startpos__1_ in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 237 "idllib/parser.mly"
                     ( PrincipalV s.it @@ at _sloc )
# 2079 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_114 =
  fun _endpos_id_ _startpos_id_ id ->
    let b =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 88 "idllib/parser.mly"
          ( id @@ at _sloc )
# 2091 "idllib/parser.ml"
      
    in
    let (_endpos_b_, _startpos_b_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_b_ in
    let _symbolstartpos = _startpos_b_ in
    let _loc_b_ = (_startpos_b_, _endpos_b_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 239 "idllib/parser.mly"
    ( match b.it with
      | "null" -> NullV @@ at _sloc
      | "true" -> BoolV true @@ at _sloc
      | "false" -> BoolV false @@ at _sloc
      | _ -> raise (ParseError (at _loc_b_, b.it))
    )
# 2107 "idllib/parser.ml"
     : (Syntax.value' Source.phrase))

let _menhir_action_115 =
  fun f ->
    (
# 119 "idllib/parser.mly"
                ( f )
# 2115 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_116 =
  fun _endpos_id_ _startpos_id_ id ->
    let name =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 2127 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_name_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 121 "idllib/parser.mly"
    ( { label = Named name.it @@ at _loc_name_; typ = PrimT Null @@ no_region } @@ at _sloc )
# 2138 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_117 =
  fun _endpos_s_ _startpos_s_ s ->
    let name =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 2153 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 2163 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_s_, _startpos_s_) in
    let _endpos = _endpos_name_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 121 "idllib/parser.mly"
    ( { label = Named name.it @@ at _loc_name_; typ = PrimT Null @@ no_region } @@ at _sloc )
# 2174 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_118 =
  fun _endpos_n_ _startpos_n_ n ->
    let _endpos = _endpos_n_ in
    let _symbolstartpos = _startpos_n_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 123 "idllib/parser.mly"
    ( { label = Id (Uint32.of_string n) @@ at _loc_n_; typ = PrimT Null @@ no_region } @@ at _sloc )
# 2186 "idllib/parser.ml"
     : (Syntax.typ_field' Source.phrase))

let _menhir_action_119 =
  fun fs ->
    (
# 130 "idllib/parser.mly"
                                                     ( fs )
# 2194 "idllib/parser.ml"
     : (Syntax.typ_field list))

let _menhir_action_120 =
  fun _endpos_n_ _endpos_v_ _startpos_n_ n v ->
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_n_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 248 "idllib/parser.mly"
    ( (Id (Uint32.of_string n) @@ at _loc_n_, v ) @@ at _sloc )
# 2206 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_action_121 =
  fun _endpos_id_ _endpos_v_ _startpos_id_ id v ->
    let name =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 2218 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 250 "idllib/parser.mly"
    ( (Named name.it @@ at _loc_name_, v) @@ at _sloc )
# 2229 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_action_122 =
  fun _endpos_s_ _endpos_v_ _startpos_s_ s v ->
    let name =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 2244 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 2254 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_s_, _startpos_s_) in
    let _endpos = _endpos_v_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 250 "idllib/parser.mly"
    ( (Named name.it @@ at _loc_name_, v) @@ at _sloc )
# 2265 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_action_123 =
  fun _endpos_n_ _startpos_n_ n ->
    let _endpos = _endpos_n_ in
    let _symbolstartpos = _startpos_n_ in
    let _loc_n_ = (_startpos_n_, _endpos_n_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 252 "idllib/parser.mly"
    ( (Id (Uint32.of_string n) @@ at _loc_n_, NullV @@ no_region) @@ at _sloc )
# 2277 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_action_124 =
  fun _endpos_id_ _startpos_id_ id ->
    let name =
      let _endpos = _endpos_id_ in
      let _symbolstartpos = _startpos_id_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 91 "idllib/parser.mly"
          ( id @@ at _sloc )
# 2289 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_id_, _startpos_id_) in
    let _endpos = _endpos_name_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 254 "idllib/parser.mly"
    ( (Named name.it @@ at _loc_name_, NullV @@ no_region) @@ at _sloc )
# 2300 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_action_125 =
  fun _endpos_s_ _startpos_s_ s ->
    let name =
      let text =
        let _endpos = _endpos_s_ in
        let _symbolstartpos = _startpos_s_ in
        let _sloc = (_symbolstartpos, _endpos) in
        
# 83 "idllib/parser.mly"
   ( try ignore (Lib.Utf8.decode s); s
     with Lib.Utf8.Utf8 -> raise (ParseError (at _sloc, "Invalid UTF-8"))
   )
# 2315 "idllib/parser.ml"
        
      in
      let (_endpos_text_, _startpos_text_) = (_endpos_s_, _startpos_s_) in
      let _endpos = _endpos_text_ in
      let _symbolstartpos = _startpos_text_ in
      let _sloc = (_symbolstartpos, _endpos) in
      
# 92 "idllib/parser.mly"
              ( text @@ at _sloc )
# 2325 "idllib/parser.ml"
      
    in
    let (_endpos_name_, _startpos_name_) = (_endpos_s_, _startpos_s_) in
    let _endpos = _endpos_name_ in
    let _symbolstartpos = _startpos_name_ in
    let _loc_name_ = (_startpos_name_, _endpos_name_) in
    let _sloc = (_symbolstartpos, _endpos) in
    (
# 254 "idllib/parser.mly"
    ( (Named name.it @@ at _loc_name_, NullV @@ no_region) @@ at _sloc )
# 2336 "idllib/parser.ml"
     : ((Syntax.field_label * Syntax.value) Source.phrase))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | ARROW ->
        "ARROW"
    | BLOB ->
        "BLOB"
    | COLON ->
        "COLON"
    | COMMA ->
        "COMMA"
    | COMPOSITE_QUERY ->
        "COMPOSITE_QUERY"
    | EOF ->
        "EOF"
    | EQ ->
        "EQ"
    | EQQ ->
        "EQQ"
    | FUNC ->
        "FUNC"
    | ID _ ->
        "ID"
    | IMPORT ->
        "IMPORT"
    | LCURLY ->
        "LCURLY"
    | LPAR ->
        "LPAR"
    | MINUS ->
        "MINUS"
    | NAT _ ->
        "NAT"
    | NOTCOLON ->
        "NOTCOLON"
    | NOTEQ ->
        "NOTEQ"
    | ONEWAY ->
        "ONEWAY"
    | OPT ->
        "OPT"
    | PERIOD ->
        "PERIOD"
    | PRINCIPAL ->
        "PRINCIPAL"
    | QUERY ->
        "QUERY"
    | RCURLY ->
        "RCURLY"
    | RECORD ->
        "RECORD"
    | RPAR ->
        "RPAR"
    | SEMICOLON ->
        "SEMICOLON"
    | SERVICE ->
        "SERVICE"
    | TEXT _ ->
        "TEXT"
    | TYPE ->
        "TYPE"
    | VARIANT ->
        "VARIANT"
    | VEC ->
        "VEC"

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

include struct
  
  [@@@ocaml.warning "-4-37"]
  
  let _menhir_run_068 : type  ttv_stack. ttv_stack _menhir_cell0_LPAR -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let MenhirCell0_LPAR (_menhir_stack, _startpos__1_) = _menhir_stack in
          let (_endpos__4_, vs) = (_endpos, _v) in
          let _v = _menhir_action_059 _endpos__4_ _startpos__1_ vs in
          MenhirBox_parse_args _v
      | _ ->
          _eRR ()
  
  let rec _menhir_run_073 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_annval -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_annval (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_071 x xs in
      _menhir_goto_seplist_annval_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_annval_COMMA_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState072 ->
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState001 ->
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  let rec _menhir_run_002 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_VEC (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LCURLY (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | TEXT _v ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState003
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | NAT _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState003
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | ID _v ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState003
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState003
          | RCURLY ->
              let _v = _menhir_action_090 () in
              _menhir_run_065 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_004 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_VARIANT (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LCURLY (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v ->
              let _startpos_1 = _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 _menhir_stack = MenhirCell0_TEXT (_menhir_stack, _v, _startpos_1, _endpos) in
                  let _menhir_s = MenhirState007 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | VEC ->
                      _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | VARIANT ->
                      _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | TEXT _v ->
                      _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | SERVICE ->
                      _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | RECORD ->
                      _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | PRINCIPAL ->
                      _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | OPT ->
                      _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | NAT _v ->
                      _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | MINUS ->
                      _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | ID _v ->
                      _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | FUNC ->
                      _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | BLOB ->
                      _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | _ ->
                      _eRR ())
              | RCURLY ->
                  let (_endpos_s_, _startpos_s_, s) = (_endpos, _startpos_1, _v) in
                  let _v = _menhir_action_125 _endpos_s_ _startpos_s_ s in
                  _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
              | _ ->
                  _eRR ())
          | NAT _v ->
              let _startpos_5 = _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 _menhir_stack = MenhirCell0_NAT (_menhir_stack, _v, _startpos_5, _endpos) in
                  let _menhir_s = MenhirState055 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | VEC ->
                      _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | VARIANT ->
                      _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | TEXT _v ->
                      _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | SERVICE ->
                      _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | RECORD ->
                      _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | PRINCIPAL ->
                      _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | OPT ->
                      _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | NAT _v ->
                      _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | MINUS ->
                      _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | ID _v ->
                      _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | FUNC ->
                      _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | BLOB ->
                      _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | _ ->
                      _eRR ())
              | RCURLY ->
                  let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos_5, _v) in
                  let _v = _menhir_action_123 _endpos_n_ _startpos_n_ n in
                  _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
              | _ ->
                  _eRR ())
          | ID _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
              | EQ ->
                  let _menhir_stack = MenhirCell0_ID (_menhir_stack, _v, _startpos_9, _endpos) in
                  let _menhir_s = MenhirState058 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | VEC ->
                      _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | VARIANT ->
                      _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | TEXT _v ->
                      _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | SERVICE ->
                      _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | RECORD ->
                      _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | PRINCIPAL ->
                      _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | OPT ->
                      _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | NAT _v ->
                      _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | MINUS ->
                      _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | ID _v ->
                      _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | FUNC ->
                      _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | BLOB ->
                      _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | _ ->
                      _eRR ())
              | RCURLY ->
                  let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos_9, _v) in
                  let _v = _menhir_action_124 _endpos_id_ _startpos_id_ id in
                  _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_008 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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_text_, _startpos_text_, text) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_103 _endpos_text_ _startpos_text_ text in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_text_ _startpos_text_ _v _menhir_s _tok
  
  and _menhir_goto_value : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState072 ->
          _menhir_run_067 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState001 ->
          _menhir_run_067 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState063 ->
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState003 ->
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState058 ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState055 ->
          _menhir_run_056 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState007 ->
          _menhir_run_053 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState051 ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState013 ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState045 ->
          _menhir_run_046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState042 ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState015 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState019 ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_067 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let v = _v in
      let _v = _menhir_action_010 v in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_annval (_menhir_stack, _menhir_s, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | TEXT _v_0 ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState072
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | NAT _v_1 ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState072
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | ID _v_2 ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState072
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
          | RPAR ->
              let _v_3 = _menhir_action_069 () in
              _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3
          | _ ->
              _eRR ())
      | RPAR ->
          let x = _v in
          let _v = _menhir_action_070 x in
          _menhir_goto_seplist_annval_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_009 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | TEXT _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos_s_, _startpos_s_, s, _startpos__1_) = (_endpos, _startpos_0, _v, _startpos) in
          let _v = _menhir_action_107 _endpos_s_ _startpos__1_ _startpos_s_ s in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos__1_ _v _menhir_s _tok
      | ID _v ->
          let _startpos_1 = _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, _startpos__1_) = (_endpos, _startpos_1, _v, _startpos) in
          let _v = _menhir_action_106 _endpos_id_ _startpos__1_ _startpos_id_ id in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_012 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_RECORD (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LCURLY (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | TEXT _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState013
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | NAT _v ->
              _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState013
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | ID _v ->
              _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState013
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
          | RCURLY ->
              let _v = _menhir_action_075 () in
              _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_014 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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 _menhir_stack = MenhirCell1_TEXT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState015 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | TEXT _v ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NAT _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RCURLY | SEMICOLON ->
          let (_endpos_text_, _startpos_text_, text) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_103 _endpos_text_ _startpos_text_ text in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_text_ _startpos_text_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_016 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | TEXT _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos_s_, _startpos_s_, s, _startpos__1_) = (_endpos_1, _startpos_0, _v, _startpos) in
          let _v = _menhir_action_113 _endpos_s_ _startpos__1_ _startpos_s_ s in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos__1_ _v _menhir_s _tok
      | ID _v ->
          let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos_id_, _startpos_id_, id, _startpos__1_) = (_endpos_3, _startpos_2, _v, _startpos) in
          let _v = _menhir_action_112 _endpos_id_ _startpos__1_ _startpos_id_ id in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_019 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_OPT (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState019 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | TEXT _v ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | SERVICE ->
          _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | NAT _v ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MINUS ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_020 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | PERIOD ->
          let _menhir_stack = MenhirCell1_NAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_021 _menhir_stack _menhir_lexbuf _menhir_lexer
      | COMMA | RCURLY | RPAR | SEMICOLON ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_050 n in
          _menhir_goto_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_021 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_NAT -> _ -> _ -> _menhir_box_parse_args =
    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
      | NAT _v ->
          let _menhir_stack = MenhirCell0_PERIOD (_menhir_stack, _endpos) in
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState021
      | COMMA | RCURLY | RPAR | SEMICOLON ->
          let MenhirCell1_NAT (_menhir_stack, _menhir_s, n, _startpos_n_, _) = _menhir_stack in
          let _endpos__2_ = _endpos in
          let _v = _menhir_action_049 n in
          _menhir_goto_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_num : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState072 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState001 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState003 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState063 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState058 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState055 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState007 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState051 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState013 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState045 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState042 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState015 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState019 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState023 ->
          _menhir_run_024 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState021 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_039 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_097 n in
      _menhir_goto_signed_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
  
  and _menhir_goto_signed_num : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_099 _endpos_n_ _startpos_n_ n in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
  
  and _menhir_run_024 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_MINUS -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_n_, n) = (_endpos, _v) in
      let _v = _menhir_action_096 n in
      _menhir_goto_signed_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_022 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_NAT _menhir_cell0_PERIOD -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_PERIOD (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_NAT (_menhir_stack, _menhir_s, n, _startpos_n_, _) = _menhir_stack in
      let (_endpos_n2_, n2) = (_endpos, _v) in
      let _v = _menhir_action_048 n n2 in
      _menhir_goto_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n2_ _startpos_n_ _v _menhir_s _tok
  
  and _menhir_run_023 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_MINUS (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState023 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NAT _v ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_025 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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_114 _endpos_id_ _startpos_id_ id in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
  
  and _menhir_run_026 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | TEXT _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PERIOD ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | TEXT _v_2 ->
                  let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_endpos_s_, _startpos_s_, s, _startpos__1_, _endpos_s_inlined1_, _startpos_s_inlined1_, s_inlined1) = (_endpos, _startpos_0, _v, _startpos, _endpos_4, _startpos_3, _v_2) in
                  let _v = _menhir_action_111 _endpos_s_ _endpos_s_inlined1_ _startpos__1_ _startpos_s_ _startpos_s_inlined1_ s s_inlined1 in
                  _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_inlined1_ _startpos__1_ _v _menhir_s _tok
              | ID _v_5 ->
                  let _startpos_6 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_7 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_endpos_id_, _startpos_id_, id, _endpos_s_, _startpos_s_, s, _startpos__1_) = (_endpos_7, _startpos_6, _v_5, _endpos, _startpos_0, _v, _startpos) in
                  let _v = _menhir_action_110 _endpos_id_ _endpos_s_ _startpos__1_ _startpos_id_ _startpos_s_ id s in
                  _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos__1_ _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | ID _v ->
          let _startpos_8 = _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
          | PERIOD ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | TEXT _v_10 ->
                  let _startpos_11 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_12 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_endpos_id_, _startpos_id_, id, _endpos_s_, _startpos_s_, s, _startpos__1_) = (_endpos, _startpos_8, _v, _endpos_12, _startpos_11, _v_10, _startpos) in
                  let _v = _menhir_action_109 _endpos_id_ _endpos_s_ _startpos__1_ _startpos_id_ _startpos_s_ id s in
                  _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos__1_ _v _menhir_s _tok
              | ID _v_13 ->
                  let _startpos_14 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_15 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (_endpos_id_, _startpos_id_, id, _startpos__1_, _endpos_id_inlined1_, _startpos_id_inlined1_, id_inlined1) = (_endpos, _startpos_8, _v, _startpos, _endpos_15, _startpos_14, _v_13) in
                  let _v = _menhir_action_108 _endpos_id_ _endpos_id_inlined1_ _startpos__1_ _startpos_id_ _startpos_id_inlined1_ id id_inlined1 in
                  _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_inlined1_ _startpos__1_ _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_035 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | TEXT _v ->
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos_text_, text, _startpos__1_) = (_endpos_1, _v, _startpos) in
          let _v = _menhir_action_102 _endpos_text_ _startpos__1_ text in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_text_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_041 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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
      | PERIOD ->
          let _menhir_stack = MenhirCell1_NAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_021 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQ ->
          let _menhir_stack = MenhirCell1_NAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState042 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | TEXT _v ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NAT _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RCURLY | SEMICOLON ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_050 n in
          _menhir_goto_num _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_044 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    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 _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState045 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | TEXT _v ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NAT _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | RCURLY | SEMICOLON ->
          let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_114 _endpos_id_ _startpos_id_ id in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_048 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_RECORD _menhir_cell0_LCURLY -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LCURLY (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_RECORD (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos__4_, fs) = (_endpos, _v) in
      let _v = _menhir_action_104 _endpos__4_ _startpos__1_ fs in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_062 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_value (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | TEXT _v_1 ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState063
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | NAT _v_2 ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState063
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | ID _v_3 ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState063
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState063
          | RCURLY ->
              let _v_4 = _menhir_action_090 () in
              _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4
          | _ ->
              _eRR ())
      | RCURLY ->
          let x = _v in
          let _v = _menhir_action_091 x in
          _menhir_goto_seplist_value_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_064 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_value _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_value (_menhir_stack, _menhir_s, x, _, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_092 x xs in
      _menhir_goto_seplist_value_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_value_SEMICOLON_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState003 ->
          _menhir_run_065 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState063 ->
          _menhir_run_064 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_065 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_VEC _menhir_cell0_LCURLY -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LCURLY (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_VEC (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos__4_, vs) = (_endpos, _v) in
      let _v = _menhir_action_101 _endpos__4_ _startpos__1_ vs in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_059 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_ID -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_ID (_menhir_stack, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_121 _endpos_id_ _endpos_v_ _startpos_id_ id v in
      _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_goto_variant_value : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RCURLY ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_LCURLY (_menhir_stack, _) = _menhir_stack in
          let MenhirCell1_VARIANT (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (_endpos__4_, f) = (_endpos, _v) in
          let _v = _menhir_action_105 _endpos__4_ _startpos__1_ f in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_056 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_NAT -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_NAT (_menhir_stack, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_120 _endpos_n_ _endpos_v_ _startpos_n_ n v in
      _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_053 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_VARIANT _menhir_cell0_LCURLY _menhir_cell0_TEXT -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_TEXT (_menhir_stack, s, _startpos_s_, _endpos_s_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_122 _endpos_s_ _endpos_v_ _startpos_s_ s v in
      _menhir_goto_variant_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_047 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_v_, _startpos_v_, v) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_033 _endpos_v_ _startpos_v_ v in
      _menhir_goto_field_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_field_value : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_field_value (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | TEXT _v_0 ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState051
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | NAT _v_1 ->
              _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState051
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | ID _v_2 ->
              _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState051
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState051
          | RCURLY ->
              let _v_3 = _menhir_action_075 () in
              _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3
          | _ ->
              _eRR ())
      | RCURLY ->
          let x = _v in
          let _v = _menhir_action_076 x in
          _menhir_goto_seplist_field_value_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_052 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_field_value _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_field_value (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_077 x xs in
      _menhir_goto_seplist_field_value_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_field_value_SEMICOLON_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_args) _menhir_state -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState051 ->
          _menhir_run_052 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState013 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_046 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_031 _endpos_id_ _endpos_v_ _startpos_id_ id v in
      _menhir_goto_field_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_043 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_NAT -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_NAT (_menhir_stack, _menhir_s, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_030 _endpos_n_ _endpos_v_ _startpos_n_ n v in
      _menhir_goto_field_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_040 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_TEXT -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_TEXT (_menhir_stack, _menhir_s, s, _startpos_s_, _endpos_s_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_032 _endpos_s_ _endpos_v_ _startpos_s_ s v in
      _menhir_goto_field_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_037 : type  ttv_stack. (ttv_stack, _menhir_box_parse_args) _menhir_cell1_OPT -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_OPT (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_v_, v) = (_endpos, _v) in
      let _v = _menhir_action_100 _endpos_v_ _startpos__1_ v in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_v_ _startpos__1_ _v _menhir_s _tok
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_args =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LPAR ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LPAR (_menhir_stack, _startpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_002 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | VARIANT ->
              _menhir_run_004 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | TEXT _v ->
              _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState001
          | SERVICE ->
              _menhir_run_009 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | RECORD ->
              _menhir_run_012 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | PRINCIPAL ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | OPT ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | NAT _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState001
          | MINUS ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | ID _v ->
              _menhir_run_025 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState001
          | FUNC ->
              _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | BLOB ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState001
          | RPAR ->
              let _v = _menhir_action_069 () in
              _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  let _menhir_run_208 : type  ttv_stack. (ttv_stack, _menhir_box_parse_tests) _menhir_cell1_endlist_def_SEMICOLON_ -> _ -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v ->
      let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
      let MenhirCell1_endlist_def_SEMICOLON_ (_menhir_stack, _, tdecs, _startpos_tdecs_, _endpos_tdecs_) = _menhir_stack in
      let (_endpos__3_, _startpos__3_, _endpos_tests_, _startpos_tests_, tests) = (_endpos_1, _startpos_0, _endpos, _startpos, _v) in
      let _v = _menhir_action_061 _endpos__3_ _endpos_tdecs_ _endpos_tests_ _startpos__3_ _startpos_tdecs_ _startpos_tests_ tdecs tests in
      MenhirBox_parse_tests _v
  
  let _menhir_goto_actor : type  ttv_stack. (ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let MenhirCell1_seplist_def_SEMICOLON_ (_menhir_stack, _, ds, _startpos_ds_, _endpos_ds_) = _menhir_stack in
          let (_endpos__3_, _startpos__3_, _endpos_actor_, _startpos_actor_, actor) = (_endpos_1, _startpos_0, _endpos, _startpos, _v) in
          let _v = _menhir_action_060 _endpos__3_ _endpos_actor_ _endpos_ds_ _startpos__3_ _startpos_actor_ _startpos_ds_ actor ds in
          MenhirBox_parse_prog _v
      | _ ->
          _eRR ()
  
  let _menhir_run_178 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_actor_class_typ -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _endpos _tok ->
      let MenhirCell1_actor_class_typ (_menhir_stack, _, t) = _menhir_stack in
      let MenhirCell0_id_opt (_menhir_stack, _) = _menhir_stack in
      let MenhirCell0_SERVICE (_menhir_stack, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_006 t in
      _menhir_goto_actor _menhir_stack _menhir_lexbuf _endpos__5_ _startpos__1_ _v _tok
  
  let _menhir_run_176 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_actor_typ -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _endpos _tok ->
      let MenhirCell1_actor_typ (_menhir_stack, _, tys, _startpos_tys_, _endpos_tys_) = _menhir_stack in
      let MenhirCell0_id_opt (_menhir_stack, _) = _menhir_stack in
      let MenhirCell0_SERVICE (_menhir_stack, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_004 _endpos_tys_ _startpos_tys_ tys in
      _menhir_goto_actor _menhir_stack _menhir_lexbuf _endpos__5_ _startpos__1_ _v _tok
  
  let _menhir_run_170 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_ID -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _endpos _tok ->
      let MenhirCell1_ID (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let MenhirCell0_id_opt (_menhir_stack, _) = _menhir_stack in
      let MenhirCell0_SERVICE (_menhir_stack, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_005 _endpos_id_ _startpos_id_ id in
      _menhir_goto_actor _menhir_stack _menhir_lexbuf _endpos__5_ _startpos__1_ _v _tok
  
  let _menhir_goto_option_SEMICOLON_ : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_prog) _menhir_state -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _endpos _menhir_s _tok ->
      match _menhir_s with
      | MenhirState177 ->
          _menhir_run_178 _menhir_stack _menhir_lexbuf _endpos _tok
      | MenhirState175 ->
          _menhir_run_176 _menhir_stack _menhir_lexbuf _endpos _tok
      | MenhirState168 ->
          _menhir_run_170 _menhir_stack _menhir_lexbuf _endpos _tok
      | _ ->
          _menhir_fail ()
  
  let _menhir_run_169 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_prog) _menhir_state -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_x_, x) = (_endpos, ()) in
      let _ = _menhir_action_052 x in
      _menhir_goto_option_SEMICOLON_ _menhir_stack _menhir_lexbuf _endpos_x_ _menhir_s _tok
  
  let rec _menhir_run_207 : type  ttv_stack. (ttv_stack, _menhir_box_parse_tests) _menhir_cell1_test _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _endpos _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_test (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_089 x xs in
      _menhir_goto_seplist_test_SEMICOLON_ _menhir_stack _menhir_lexbuf _endpos_xs_ _startpos_x_ _v _menhir_s
  
  and _menhir_goto_seplist_test_SEMICOLON_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _endpos _startpos _v _menhir_s ->
      match _menhir_s with
      | MenhirState187 ->
          _menhir_run_208 _menhir_stack _menhir_lexbuf _endpos _startpos _v
      | MenhirState206 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _endpos _v
      | _ ->
          _menhir_fail ()
  
  let _menhir_goto_actor_class_typ : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_prog) _menhir_state -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_actor_class_typ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          _menhir_run_169 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState177
      | EOF ->
          let _ = _menhir_action_051 () in
          _menhir_run_178 _menhir_stack _menhir_lexbuf _endpos _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_175 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_prog) _menhir_state -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_actor_typ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          _menhir_run_169 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState175
      | EOF ->
          let _ = _menhir_action_051 () in
          _menhir_run_176 _menhir_stack _menhir_lexbuf _endpos _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_174 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt, _menhir_box_parse_prog) _menhir_cell1_param_typs -> _ -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      let MenhirCell1_param_typs (_menhir_stack, _menhir_s, args, _startpos_args_) = _menhir_stack in
      let (_endpos_tys_, _startpos_tys_, tys) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_007 _endpos_tys_ _startpos_args_ _startpos_tys_ args tys in
      _menhir_goto_actor_class_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  let rec _menhir_run_076 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_ID (_menhir_stack, _v, _startpos, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | EQ ->
              let _menhir_s = MenhirState078 in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | VEC ->
                  _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | VARIANT ->
                  _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | SERVICE ->
                  _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | RECORD ->
                  _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | PRINCIPAL ->
                  _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | OPT ->
                  _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | ID _v ->
                  _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
              | FUNC ->
                  _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | BLOB ->
                  _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_079 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_VEC (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState079 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_080 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_VARIANT (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LCURLY (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v ->
              _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState081
          | NAT _v ->
              _menhir_run_150 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState081
          | ID _v ->
              _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState081
          | RCURLY ->
              let _v = _menhir_action_093 () in
              _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_082 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_TEXT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer
      | RCURLY | SEMICOLON ->
          let (_endpos_s_, _startpos_s_, s) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_117 _endpos_s_ _startpos_s_ s in
          _menhir_goto_variant_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_083 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_TEXT -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState083 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_084 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_SERVICE (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState084 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_085 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_LCURLY (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TEXT _v ->
          _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState085
      | ID _v ->
          _menhir_run_139 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState085
      | RCURLY ->
          let _v = _menhir_action_078 () in
          _menhir_run_143 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_086 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAR ->
              let _menhir_stack = MenhirCell1_TEXT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState087
          | ID _v_0 ->
              let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_endpos_id_, _startpos_id_, id, _endpos_s_, _startpos_s_, s) = (_endpos_2, _startpos_1, _v_0, _endpos, _startpos, _v) in
              let _v = _menhir_action_047 _endpos_id_ _endpos_s_ _startpos_id_ _startpos_s_ id s in
              _menhir_goto_meth_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_088 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_LPAR (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | TEXT _v ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState088
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | ID _v ->
          _menhir_run_128 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState088
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
      | RPAR ->
          let _v = _menhir_action_081 () in
          _menhir_run_131 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_089 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_TEXT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_s = MenhirState090 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | VARIANT ->
              _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | SERVICE ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RECORD ->
              _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PRINCIPAL ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | OPT ->
              _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNC ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | BLOB ->
              _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_091 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_RECORD (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LCURLY ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_LCURLY (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | VARIANT ->
              _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | TEXT _v ->
              _menhir_run_093 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState092
          | SERVICE ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | RECORD ->
              _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | PRINCIPAL ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | OPT ->
              _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | NAT _v ->
              _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState092
          | ID _v ->
              _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState092
          | FUNC ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | BLOB ->
              _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState092
          | RCURLY ->
              let _v = _menhir_action_084 () in
              _menhir_run_119 _menhir_stack _menhir_lexbuf _menhir_lexer _v
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_093 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_TEXT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          _menhir_run_083 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_094 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_068 _endpos__1_ _startpos__1_ in
      _menhir_goto_ref_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_ref_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_t_, _startpos_t_, t) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_021 t in
      _menhir_goto_data_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos_t_ _v _menhir_s _tok
  
  and _menhir_goto_data_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState078 ->
          _menhir_run_160 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState079 ->
          _menhir_run_159 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState083 ->
          _menhir_run_149 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState088 ->
          _menhir_run_136 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState134 ->
          _menhir_run_136 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState129 ->
          _menhir_run_130 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState090 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState092 ->
          _menhir_run_125 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState122 ->
          _menhir_run_125 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState117 ->
          _menhir_run_118 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState114 ->
          _menhir_run_115 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState095 ->
          _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_160 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_TYPE _menhir_cell0_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_ID (_menhir_stack, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let MenhirCell1_TYPE (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_023 _endpos_id_ _endpos_t_ _startpos__1_ _startpos_id_ id t in
      _menhir_goto_def _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_def : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState185 ->
          _menhir_run_210 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState211 ->
          _menhir_run_182 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState183 ->
          _menhir_run_182 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState075 ->
          _menhir_run_182 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_210 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_def (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TYPE ->
              _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState211
          | IMPORT ->
              _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState211
          | EOF | ID _ ->
              let _v_1 = _menhir_action_072 () in
              _menhir_run_212 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_0 _v_1 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_161 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TEXT _v ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos_s_, _startpos_s_, s, _startpos__1_) = (_endpos, _startpos_0, _v, _startpos) in
          let _v = _menhir_action_024 _endpos_s_ _startpos__1_ _startpos_s_ s in
          _menhir_goto_def _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_212 : type  ttv_stack. (ttv_stack, _menhir_box_parse_tests) _menhir_cell1_def _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_def (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_026 x xs in
      _menhir_goto_endlist_def_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_endlist_def_SEMICOLON_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_endlist_def_SEMICOLON_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          _menhir_run_188 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState187
      | EOF ->
          let _v_1 = _menhir_action_087 () in
          _menhir_run_208 _menhir_stack _menhir_lexbuf _endpos _endpos _v_1
      | _ ->
          _eRR ()
  
  and _menhir_run_188 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _menhir_box_parse_tests =
    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_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _menhir_s = MenhirState188 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TEXT _v ->
          _menhir_run_189 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | BLOB ->
          _menhir_run_190 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_189 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _menhir_box_parse_tests =
    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_s_, _startpos_s_, s) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_042 _endpos_s_ _startpos_s_ s in
      _menhir_goto_input _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_input : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState197 ->
          _menhir_run_198 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState193 ->
          _menhir_run_194 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState188 ->
          _menhir_run_192 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_198 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_input -> _ -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_input (_menhir_stack, _menhir_s, i1) = _menhir_stack in
          let i2 = _v in
          let _v = _menhir_action_013 i1 i2 in
          _menhir_goto_assertion _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_assertion : type  ttv_stack. ((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_assertion (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LPAR ->
          _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState201
      | _ ->
          _eRR ()
  
  and _menhir_run_194 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_input -> _ -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_input (_menhir_stack, _menhir_s, i1) = _menhir_stack in
          let i2 = _v in
          let _v = _menhir_action_014 i1 i2 in
          _menhir_goto_assertion _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_192 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | NOTEQ ->
          let _menhir_stack = MenhirCell1_input (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState193 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v ->
              _menhir_run_189 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | BLOB ->
              _menhir_run_190 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | NOTCOLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let input = _v in
          let _v = _menhir_action_012 input in
          _menhir_goto_assertion _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | EQQ ->
          let _menhir_stack = MenhirCell1_input (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState197 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v ->
              _menhir_run_189 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | BLOB ->
              _menhir_run_190 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let input = _v in
          let _v = _menhir_action_011 input in
          _menhir_goto_assertion _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_190 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_parse_tests) _menhir_state -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TEXT _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let text = _v in
          let _v = _menhir_action_043 text in
          _menhir_goto_input _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_182 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_def (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TYPE ->
              _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | IMPORT ->
              _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState183
          | EOF | ID _ | SERVICE ->
              let _v_1 = _menhir_action_072 () in
              _menhir_run_184 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_0 _v_1 _tok
          | _ ->
              _eRR ())
      | EOF | ID _ | SERVICE ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_073 x in
          _menhir_goto_seplist_def_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_184 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_def _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_def (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_074 x xs in
      _menhir_goto_seplist_def_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_seplist_def_SEMICOLON_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState211 ->
          _menhir_run_212 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState183 ->
          _menhir_run_184 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState075 ->
          _menhir_run_163 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_163 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_parse_prog) _menhir_state -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_seplist_def_SEMICOLON_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SERVICE ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _menhir_stack = MenhirCell0_SERVICE (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v_1 ->
              let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_endpos_id_, _startpos_id_, id) = (_endpos_3, _startpos_2, _v_1) in
              let _v = _menhir_action_041 _endpos_id_ _startpos_id_ id in
              _menhir_goto_id_opt _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | COLON ->
              let _v = _menhir_action_040 () in
              _menhir_goto_id_opt _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
          | _ ->
              _eRR ())
      | EOF ->
          let _v = _menhir_action_003 () in
          _menhir_goto_actor _menhir_stack _menhir_lexbuf _endpos _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_id_opt : type  ttv_stack. (ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE -> _ -> _ -> _ -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_id_opt (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAR ->
              _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState167
          | LCURLY ->
              _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState167
          | ID _v_0 ->
              let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _menhir_stack = MenhirCell1_ID (_menhir_stack, MenhirState167, _v_0, _startpos, _endpos) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | SEMICOLON ->
                  _menhir_run_169 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState168
              | EOF ->
                  let _ = _menhir_action_051 () in
                  _menhir_run_170 _menhir_stack _menhir_lexbuf _endpos _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_159 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_VEC -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_VEC (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_016 _endpos_t_ _startpos__1_ t in
      _menhir_goto_cons_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_cons_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_t_, _startpos_t_, t) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_020 t in
      _menhir_goto_data_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos_t_ _v _menhir_s _tok
  
  and _menhir_run_149 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_TEXT -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_TEXT (_menhir_stack, _menhir_s, s, _startpos_s_, _endpos_s_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_029 _endpos_s_ _endpos_t_ _startpos_s_ s t in
      _menhir_goto_field_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_field_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState081 ->
          _menhir_run_155 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState153 ->
          _menhir_run_155 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState092 ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState122 ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_155 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let f = _v in
      let _v = _menhir_action_115 f in
      _menhir_goto_variant_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_variant_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_variant_typ (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v_0 ->
              _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState153
          | NAT _v_1 ->
              _menhir_run_150 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState153
          | ID _v_2 ->
              _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState153
          | RCURLY ->
              let _v_3 = _menhir_action_093 () in
              _menhir_run_154 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3
          | _ ->
              _eRR ())
      | RCURLY ->
          let x = _v in
          let _v = _menhir_action_094 x in
          _menhir_goto_seplist_variant_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_150 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_NAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer
      | RCURLY | SEMICOLON ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_118 _endpos_n_ _startpos_n_ n in
          _menhir_goto_variant_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_114 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_NAT -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState114 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_095 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_OPT (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState095 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_096 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_062 _endpos_id_ _startpos_id_ id in
      _menhir_goto_prim_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
  
  and _menhir_goto_prim_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_t_, _startpos_t_, t) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_022 t in
      _menhir_goto_data_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos_t_ _v _menhir_s _tok
  
  and _menhir_run_097 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_FUNC (_menhir_stack, _menhir_s, _startpos) in
      let _menhir_s = MenhirState097 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LPAR ->
          _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_108 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_019 _endpos__1_ _startpos__1_ in
      _menhir_goto_cons_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_151 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_117 _menhir_stack _menhir_lexbuf _menhir_lexer
      | RCURLY | SEMICOLON ->
          let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_116 _endpos_id_ _startpos_id_ id in
          _menhir_goto_variant_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_117 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState117 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | VEC ->
          _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | VARIANT ->
          _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | SERVICE ->
          _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | RECORD ->
          _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | PRINCIPAL ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | OPT ->
          _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | FUNC ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | BLOB ->
          _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_154 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_variant_typ _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_variant_typ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_095 x xs in
      _menhir_goto_seplist_variant_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_variant_typ_SEMICOLON_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState081 ->
          _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState153 ->
          _menhir_run_154 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_156 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_VARIANT _menhir_cell0_LCURLY -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LCURLY (_menhir_stack, _) = _menhir_stack in
      let (_endpos__3_, fs) = (_endpos, _v) in
      let _v = _menhir_action_119 fs in
      let _endpos = _endpos__3_ in
      let MenhirCell1_VARIANT (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_fs_, fs) = (_endpos, _v) in
      let _v = _menhir_action_018 _endpos_fs_ _startpos__1_ fs in
      _menhir_goto_cons_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_fs_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_124 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let f = _v in
      let _v = _menhir_action_063 f in
      _menhir_goto_record_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_record_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_record_typ (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | VARIANT ->
              _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | TEXT _v_0 ->
              _menhir_run_093 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState122
          | SERVICE ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | RECORD ->
              _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | PRINCIPAL ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | OPT ->
              _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | NAT _v_1 ->
              _menhir_run_113 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState122
          | ID _v_2 ->
              _menhir_run_116 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState122
          | FUNC ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | BLOB ->
              _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState122
          | RCURLY ->
              let _v_3 = _menhir_action_084 () in
              _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3
          | _ ->
              _eRR ())
      | RCURLY ->
          let x = _v in
          let _v = _menhir_action_085 x in
          _menhir_goto_seplist_record_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_113 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_NAT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          _menhir_run_114 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_run_116 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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
      | COLON ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_117 _menhir_stack _menhir_lexbuf _menhir_lexer
      | RCURLY | SEMICOLON ->
          let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_062 _endpos_id_ _startpos_id_ id in
          _menhir_goto_prim_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_123 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_record_typ _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_record_typ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_086 x xs in
      _menhir_goto_seplist_record_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_record_typ_SEMICOLON_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState122 ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState092 ->
          _menhir_run_119 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_119 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_RECORD _menhir_cell0_LCURLY -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell0_LCURLY (_menhir_stack, _) = _menhir_stack in
      let (_endpos__3_, fs) = (_endpos, _v) in
      let _v = _menhir_action_065 fs in
      let _endpos = _endpos__3_ in
      let MenhirCell1_RECORD (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_fs_, fs) = (_endpos, _v) in
      let _v = _menhir_action_017 _endpos_fs_ _startpos__1_ fs in
      _menhir_goto_cons_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_fs_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_136 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let t = _v in
      let _v = _menhir_action_055 t in
      _menhir_goto_param_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_param_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          let _menhir_stack = MenhirCell1_param_typ (_menhir_stack, _menhir_s, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | VARIANT ->
              _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | TEXT _v_0 ->
              _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState134
          | SERVICE ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | RECORD ->
              _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | PRINCIPAL ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | OPT ->
              _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | ID _v_1 ->
              _menhir_run_128 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState134
          | FUNC ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | BLOB ->
              _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
          | RPAR ->
              let _v_2 = _menhir_action_081 () in
              _menhir_run_135 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2
          | _ ->
              _eRR ())
      | RPAR ->
          let x = _v in
          let _v = _menhir_action_082 x in
          _menhir_goto_seplist_param_typ_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_128 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState129 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | VEC ->
              _menhir_run_079 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | VARIANT ->
              _menhir_run_080 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | SERVICE ->
              _menhir_run_084 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | RECORD ->
              _menhir_run_091 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PRINCIPAL ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | OPT ->
              _menhir_run_095 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNC ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | BLOB ->
              _menhir_run_108 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | COMMA | RPAR ->
          let (_endpos_id_, _startpos_id_, id) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_062 _endpos_id_ _startpos_id_ id in
          _menhir_goto_prim_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_id_ _startpos_id_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_135 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_param_typ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell1_param_typ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_083 x xs in
      _menhir_goto_seplist_param_typ_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_param_typ_COMMA_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState134 ->
          _menhir_run_135 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState088 ->
          _menhir_run_131 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_131 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_LPAR -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_LPAR (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let fs = _v in
      let _v = _menhir_action_058 fs in
      _menhir_goto_param_typs _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_param_typs : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState201 ->
          _menhir_run_202 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState167 ->
          _menhir_run_171 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState099 ->
          _menhir_run_100 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState140 ->
          _menhir_run_098 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState087 ->
          _menhir_run_098 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState097 ->
          _menhir_run_098 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_202 : type  ttv_stack. (((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_assertion as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_tests) _menhir_state -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_param_typs (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | TEXT _v_0 ->
          let _startpos_1 = _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_s_, _startpos_s_, s) = (_endpos, _startpos_1, _v_0) in
          let _v = _menhir_action_054 _endpos_s_ _startpos_s_ s in
          _menhir_goto_option_text_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _v _tok
      | EOF | SEMICOLON ->
          let _v = _menhir_action_053 () in
          _menhir_goto_option_text_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_option_text_ : type  ttv_stack. (((ttv_stack, _menhir_box_parse_tests) _menhir_cell1_ID, _menhir_box_parse_tests) _menhir_cell1_assertion, _menhir_box_parse_tests) _menhir_cell1_param_typs -> _ -> _ -> _ -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_param_typs (_menhir_stack, _, tys, _) = _menhir_stack in
      let MenhirCell1_assertion (_menhir_stack, _, assertion) = _menhir_stack in
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_desc_, desc) = (_endpos, _v) in
      let _v = _menhir_action_098 _endpos_desc_ _endpos_id_ _startpos_id_ assertion desc id tys in
      let (_endpos, _startpos) = (_endpos_desc_, _startpos_id_) in
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_test (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v_1 ->
              _menhir_run_188 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState206
          | EOF ->
              let _v_2 = _menhir_action_087 () in
              _menhir_run_207 _menhir_stack _menhir_lexbuf _endpos_0 _v_2
          | _ ->
              _eRR ())
      | EOF ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_088 x in
          _menhir_goto_seplist_test_SEMICOLON_ _menhir_stack _menhir_lexbuf _endpos_x_ _startpos_x_ _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_171 : type  ttv_stack. ((ttv_stack, _menhir_box_parse_prog) _menhir_cell1_seplist_def_SEMICOLON_ _menhir_cell0_SERVICE _menhir_cell0_id_opt as 'stack) -> _ -> _ -> _ -> _ -> ('stack, _menhir_box_parse_prog) _menhir_state -> _ -> _menhir_box_parse_prog =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | ARROW ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LCURLY ->
              let _menhir_stack = MenhirCell1_param_typs (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_085 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState172
          | ID _v_0 ->
              let _startpos_1 = _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, _startpos_args_, args) = (_endpos, _startpos_1, _v_0, _startpos, _v) in
              let _v = _menhir_action_008 _endpos_id_ _startpos_args_ _startpos_id_ args id in
              _menhir_goto_actor_class_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_100 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_param_typs as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_param_typs (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | QUERY ->
          _menhir_run_101 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState100
      | ONEWAY ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState100
      | COMPOSITE_QUERY ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState100
      | COMMA | EOF | ID _ | RCURLY | RPAR | SEMICOLON | SERVICE ->
          let _v_0 = _menhir_action_037 () in
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_101 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_035 _endpos__1_ _startpos__1_ in
      _menhir_goto_func_mode _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_func_mode : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_func_mode (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | QUERY ->
          _menhir_run_101 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
      | ONEWAY ->
          _menhir_run_102 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
      | COMPOSITE_QUERY ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState105
      | COMMA | EOF | ID _ | RCURLY | RPAR | SEMICOLON | SERVICE ->
          let _v_0 = _menhir_action_037 () in
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_102 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_034 _endpos__1_ _startpos__1_ in
      _menhir_goto_func_mode _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_103 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos__1_, _startpos__1_) = (_endpos, _startpos) in
      let _v = _menhir_action_036 _endpos__1_ _startpos__1_ in
      _menhir_goto_func_mode _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_106 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_func_mode -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_func_mode (_menhir_stack, _menhir_s, m) = _menhir_stack in
      let (_endpos_ms_, ms) = (_endpos, _v) in
      let _v = _menhir_action_038 m ms in
      _menhir_goto_func_modes_opt _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_ms_ _v _menhir_s _tok
  
  and _menhir_goto_func_modes_opt : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState105 ->
          _menhir_run_106 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState100 ->
          _menhir_run_104 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_104 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_param_typs, ttv_result) _menhir_cell1_param_typs -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_param_typs (_menhir_stack, _, t2, _) = _menhir_stack in
      let MenhirCell1_param_typs (_menhir_stack, _menhir_s, t1, _startpos_t1_) = _menhir_stack in
      let (_endpos_ms_, ms) = (_endpos, _v) in
      let _v = _menhir_action_039 _endpos_ms_ _startpos_t1_ ms t1 t2 in
      _menhir_goto_func_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_ms_ _v _menhir_s _tok
  
  and _menhir_goto_func_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState140 ->
          _menhir_run_142 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState087 ->
          _menhir_run_138 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState097 ->
          _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_142 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_044 _endpos_id_ _endpos_t_ _startpos_id_ id t in
      _menhir_goto_meth_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_meth_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMICOLON ->
          let _menhir_stack = MenhirCell1_meth_typ (_menhir_stack, _menhir_s, _v) in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_SEMICOLON (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TEXT _v_0 ->
              _menhir_run_086 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState146
          | ID _v_1 ->
              _menhir_run_139 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState146
          | RCURLY ->
              let _v_2 = _menhir_action_078 () in
              _menhir_run_147 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2
          | _ ->
              _eRR ())
      | RCURLY ->
          let x = _v in
          let _v = _menhir_action_079 x in
          _menhir_goto_seplist_meth_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_139 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAR ->
              let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState140
          | ID _v_0 ->
              let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_endpos_id_, _startpos_id_, id, _endpos_id_inlined1_, _startpos_id_inlined1_, id_inlined1) = (_endpos_2, _startpos_1, _v_0, _endpos, _startpos, _v) in
              let _v = _menhir_action_046 _endpos_id_ _endpos_id_inlined1_ _startpos_id_ _startpos_id_inlined1_ id id_inlined1 in
              _menhir_goto_meth_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_147 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_meth_typ _menhir_cell0_SEMICOLON -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let MenhirCell0_SEMICOLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_meth_typ (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_080 x xs in
      _menhir_goto_seplist_meth_typ_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
  
  and _menhir_goto_seplist_meth_typ_SEMICOLON_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      match _menhir_s with
      | MenhirState146 ->
          _menhir_run_147 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | MenhirState085 ->
          _menhir_run_143 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_143 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_LCURLY -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_LCURLY (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos__3_, ds) = (_endpos, _v) in
      let _v = _menhir_action_009 ds in
      _menhir_goto_actor_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_actor_typ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState167 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState172 ->
          _menhir_run_174 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | MenhirState084 ->
          _menhir_run_148 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_148 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_SERVICE -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_SERVICE (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_ts_, ts) = (_endpos, _v) in
      let _v = _menhir_action_067 _endpos_ts_ _startpos__1_ ts in
      _menhir_goto_ref_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_ts_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_138 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_TEXT -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_TEXT (_menhir_stack, _menhir_s, s, _startpos_s_, _endpos_s_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_045 _endpos_s_ _endpos_t_ _startpos_s_ s t in
      _menhir_goto_meth_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_107 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_FUNC -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_FUNC (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_066 t in
      _menhir_goto_ref_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_098 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_param_typs (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | ARROW ->
          let _menhir_s = MenhirState099 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | LPAR ->
              _menhir_run_088 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_130 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_056 _endpos_id_ _startpos_id_ id t in
      _menhir_goto_param_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_127 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_TEXT -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_TEXT (_menhir_stack, _menhir_s, s, _startpos_s_, _endpos_s_) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_057 _endpos_s_ _startpos_s_ s t in
      _menhir_goto_param_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_125 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_t_, _startpos_t_, t) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_064 _endpos_t_ _startpos_t_ t in
      _menhir_goto_record_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_118 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_028 _endpos_id_ _endpos_t_ _startpos_id_ id t in
      _menhir_goto_field_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_115 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_NAT -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_NAT (_menhir_stack, _menhir_s, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_027 _endpos_n_ _endpos_t_ _startpos_n_ n t in
      _menhir_goto_field_typ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_111 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_OPT -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_OPT (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
      let (_endpos_t_, t) = (_endpos, _v) in
      let _v = _menhir_action_015 _endpos_t_ _startpos__1_ t in
      _menhir_goto_cons_typ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_t_ _startpos__1_ _v _menhir_s _tok
  
  let _menhir_run_075 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_prog =
    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
      | TYPE ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | IMPORT ->
          _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | EOF | SERVICE ->
          let _v = _menhir_action_072 () in
          _menhir_run_163 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState075 _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_185 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_parse_tests =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState185 in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TYPE ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | IMPORT ->
          _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | EOF | ID _ ->
          let _v = _menhir_action_025 () in
          _menhir_goto_endlist_def_SEMICOLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
end

let parse_tests =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_parse_tests v = _menhir_run_185 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let parse_prog =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_parse_prog v = _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let parse_args =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_parse_args v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

# 292 "idllib/parser.mly"
  

# 5055 "idllib/parser.ml"
idllib/parser.ml

37.43%
