Source file menhir_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | WHITESPACE
    | URI of 
# 28 "lib/menhir_parser.mly"
       (string)
# 16 "lib/menhir_parser.ml"
  
    | UNICODE_RANGE of 
# 37 "lib/menhir_parser.mly"
       (string)
# 21 "lib/menhir_parser.ml"
  
    | STRING of 
# 27 "lib/menhir_parser.mly"
       (string)
# 26 "lib/menhir_parser.ml"
  
    | SEMI_COLON
    | RIGHT_PAREN
    | RIGHT_BRACKET
    | RIGHT_BRACE
    | PERCENTAGE
    | OPERATOR of 
# 29 "lib/menhir_parser.mly"
       (string)
# 36 "lib/menhir_parser.ml"
  
    | NUMBER of 
# 36 "lib/menhir_parser.mly"
       (string)
# 41 "lib/menhir_parser.ml"
  
    | NESTED_AT_RULE of 
# 31 "lib/menhir_parser.mly"
       (string)
# 46 "lib/menhir_parser.ml"
  
    | LEFT_PAREN
    | LEFT_BRACKET
    | LEFT_BRACE
    | IMPORTANT
    | IDENT of 
# 26 "lib/menhir_parser.mly"
       (string)
# 55 "lib/menhir_parser.ml"
  
    | HASH of 
# 35 "lib/menhir_parser.mly"
       (string)
# 60 "lib/menhir_parser.ml"
  
    | FUNCTION of 
# 34 "lib/menhir_parser.mly"
       (string)
# 65 "lib/menhir_parser.ml"
  
    | FLOAT_DIMENSION of 
# 38 "lib/menhir_parser.mly"
       (string * string * Types.dimension)
# 70 "lib/menhir_parser.ml"
  
    | EOF
    | DOT
    | DIMENSION of 
# 39 "lib/menhir_parser.mly"
       (string * string)
# 77 "lib/menhir_parser.ml"
  
    | DELIM of 
# 30 "lib/menhir_parser.mly"
       (string)
# 82 "lib/menhir_parser.ml"
  
    | COLON
    | AT_RULE_WITHOUT_BODY of 
# 32 "lib/menhir_parser.mly"
       (string)
# 88 "lib/menhir_parser.ml"
  
    | AT_RULE of 
# 33 "lib/menhir_parser.mly"
       (string)
# 93 "lib/menhir_parser.ml"
  
  
end

include MenhirBasics

# 1 "lib/menhir_parser.mly"
  

(* Workaround for this dune bug: https://github.com/ocaml/dune/issues/2450 *)
module Css = struct end

open Types


# 109 "lib/menhir_parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState00 : ('s, _menhir_box_declaration_list) _menhir_state
    (** State 00.
        Stack shape : <empty>.
        Start symbol: declaration_list. *)

  | MenhirState01 : (('s, 'r) _menhir_cell1_NESTED_AT_RULE, 'r) _menhir_state
    (** State 01.
        Stack shape : NESTED_AT_RULE.
        Start symbol: <undetermined>. *)

  | MenhirState09 : (('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_state
    (** State 09.
        Stack shape : LEFT_PAREN.
        Start symbol: <undetermined>. *)

  | MenhirState17 : (('s, 'r) _menhir_cell1_LEFT_BRACKET, 'r) _menhir_state
    (** State 17.
        Stack shape : LEFT_BRACKET.
        Start symbol: <undetermined>. *)

  | MenhirState19 : (('s, 'r) _menhir_cell1_FUNCTION, 'r) _menhir_state
    (** State 19.
        Stack shape : FUNCTION.
        Start symbol: <undetermined>. *)

  | MenhirState30 : (('s, 'r) _menhir_cell1_component_value_with_loc, 'r) _menhir_state
    (** State 30.
        Stack shape : component_value_with_loc.
        Start symbol: <undetermined>. *)

  | MenhirState40 : (('s, 'r) _menhir_cell1_FUNCTION, 'r) _menhir_state
    (** State 40.
        Stack shape : FUNCTION.
        Start symbol: <undetermined>. *)

  | MenhirState49 : ((('s, 'r) _menhir_cell1_NESTED_AT_RULE, 'r) _menhir_cell1_prelude_with_loc, 'r) _menhir_state
    (** State 49.
        Stack shape : NESTED_AT_RULE prelude_with_loc.
        Start symbol: <undetermined>. *)

  | MenhirState50 : (('s, 'r) _menhir_cell1_AT_RULE_WITHOUT_BODY, 'r) _menhir_state
    (** State 50.
        Stack shape : AT_RULE_WITHOUT_BODY.
        Start symbol: <undetermined>. *)

  | MenhirState56 : (('s, 'r) _menhir_cell1_component_value_with_loc_in_prelude, 'r) _menhir_state
    (** State 56.
        Stack shape : component_value_with_loc_in_prelude.
        Start symbol: <undetermined>. *)

  | MenhirState60 : (('s, 'r) _menhir_cell1_AT_RULE, 'r) _menhir_state
    (** State 60.
        Stack shape : AT_RULE.
        Start symbol: <undetermined>. *)

  | MenhirState62 : ((('s, 'r) _menhir_cell1_AT_RULE, 'r) _menhir_cell1_prelude_with_loc, 'r) _menhir_state
    (** State 62.
        Stack shape : AT_RULE prelude_with_loc.
        Start symbol: <undetermined>. *)

  | MenhirState63 : (('s, 'r) _menhir_cell1_IDENT, 'r) _menhir_state
    (** State 63.
        Stack shape : IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState65 : ((('s, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_option_WHITESPACE_ _menhir_cell0_COLON, 'r) _menhir_state
    (** State 65.
        Stack shape : IDENT option(WHITESPACE) COLON.
        Start symbol: <undetermined>. *)

  | MenhirState70 : (('s, 'r) _menhir_cell1_declarations_without_ending_semi_colon _menhir_cell0_SEMI_COLON, 'r) _menhir_state
    (** State 70.
        Stack shape : declarations_without_ending_semi_colon SEMI_COLON.
        Start symbol: <undetermined>. *)

  | MenhirState81 : (('s, 'r) _menhir_cell1_rule, 'r) _menhir_state
    (** State 81.
        Stack shape : rule.
        Start symbol: <undetermined>. *)

  | MenhirState83 : (('s, 'r) _menhir_cell1_prelude_with_loc, 'r) _menhir_state
    (** State 83.
        Stack shape : prelude_with_loc.
        Start symbol: <undetermined>. *)

  | MenhirState93 : ('s, _menhir_box_stylesheet) _menhir_state
    (** State 93.
        Stack shape : <empty>.
        Start symbol: stylesheet. *)


and ('s, 'r) _menhir_cell1_component_value_with_loc = 
  | MenhirCell1_component_value_with_loc of 's * ('s, 'r) _menhir_state * (Types.Component_value.t Types.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_component_value_with_loc_in_prelude = 
  | MenhirCell1_component_value_with_loc_in_prelude of 's * ('s, 'r) _menhir_state * (Types.Component_value.t Types.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_declarations_without_ending_semi_colon = 
  | MenhirCell1_declarations_without_ending_semi_colon of 's * ('s, 'r) _menhir_state * (Types.Declaration_list.kind list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_list_component_value_with_loc_ = 
  | MenhirCell1_list_component_value_with_loc_ of 's * ('s, 'r) _menhir_state * (Types.Component_value.t Types.with_loc list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_option_WHITESPACE_ = 
  | MenhirCell1_option_WHITESPACE_ of 's * ('s, 'r) _menhir_state * (unit option) * Lexing.position

and ('s, 'r) _menhir_cell1_prelude_with_loc = 
  | MenhirCell1_prelude_with_loc of 's * ('s, 'r) _menhir_state * (Types.Component_value.t Types.with_loc list Types.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_rule = 
  | MenhirCell1_rule of 's * ('s, 'r) _menhir_state * (Types.Rule.t) * Lexing.position

and ('s, 'r) _menhir_cell1_AT_RULE = 
  | MenhirCell1_AT_RULE of 's * ('s, 'r) _menhir_state * 
# 33 "lib/menhir_parser.mly"
       (string)
# 228 "lib/menhir_parser.ml"
 * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_AT_RULE_WITHOUT_BODY = 
  | MenhirCell1_AT_RULE_WITHOUT_BODY of 's * ('s, 'r) _menhir_state * 
# 32 "lib/menhir_parser.mly"
       (string)
# 235 "lib/menhir_parser.ml"
 * Lexing.position * Lexing.position

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

and ('s, 'r) _menhir_cell1_FUNCTION = 
  | MenhirCell1_FUNCTION of 's * ('s, 'r) _menhir_state * 
# 34 "lib/menhir_parser.mly"
       (string)
# 245 "lib/menhir_parser.ml"
 * Lexing.position * Lexing.position

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

and ('s, 'r) _menhir_cell1_LEFT_BRACKET = 
  | MenhirCell1_LEFT_BRACKET of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_LEFT_PAREN = 
  | MenhirCell1_LEFT_PAREN of 's * ('s, 'r) _menhir_state * Lexing.position

and ('s, 'r) _menhir_cell1_NESTED_AT_RULE = 
  | MenhirCell1_NESTED_AT_RULE of 's * ('s, 'r) _menhir_state * 
# 31 "lib/menhir_parser.mly"
       (string)
# 265 "lib/menhir_parser.ml"
 * Lexing.position * Lexing.position

and 's _menhir_cell0_SEMI_COLON = 
  | MenhirCell0_SEMI_COLON of 's * Lexing.position

and _menhir_box_stylesheet = 
  | MenhirBox_stylesheet of (Types.Stylesheet.t) [@@unboxed]

and _menhir_box_declaration_list = 
  | MenhirBox_declaration_list of (Css__Types.Declaration_list.t) [@@unboxed]

let _menhir_action_02 =
  fun _endpos__3_ _endpos_name_ _startpos_name_ name xs ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos_name_ in
    (
# 64 "lib/menhir_parser.mly"
                                                                   (
      { At_rule.name = (name, Lex_buffer.make_loc_and_fix _startpos_name_ _endpos_name_);
        prelude = xs;
        block = Brace_block.Empty;
        loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
      }
    )
# 290 "lib/menhir_parser.ml"
     : (Types.At_rule.t))

let _menhir_action_03 =
  fun _endpos__5_ _endpos_name_ _startpos_name_ name s xs ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos_name_ in
    (
# 71 "lib/menhir_parser.mly"
                                                                                                      (
      { At_rule.name = (name, Lex_buffer.make_loc_and_fix _startpos_name_ _endpos_name_);
        prelude = xs;
        block = Brace_block.Stylesheet s;
        loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
      }
    )
# 306 "lib/menhir_parser.ml"
     : (Types.At_rule.t))

let _menhir_action_04 =
  fun _endpos__5_ _endpos_name_ _startpos_name_ ds name xs ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos_name_ in
    (
# 78 "lib/menhir_parser.mly"
                                                                                               (
      { At_rule.name = (name, Lex_buffer.make_loc_and_fix _startpos_name_ _endpos_name_);
        prelude = xs;
        block = Brace_block.Declaration_list ds;
        loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
      }
    )
# 322 "lib/menhir_parser.ml"
     : (Types.At_rule.t))

let _menhir_action_05 =
  fun () ->
    (
# 134 "<standard.mly>"
    ( false )
# 330 "lib/menhir_parser.ml"
     : (bool))

let _menhir_action_06 =
  fun () ->
    (
# 137 "<standard.mly>"
    ( true )
# 338 "lib/menhir_parser.ml"
     : (bool))

let _menhir_action_07 =
  fun xs ->
    (
# 144 "lib/menhir_parser.mly"
                                                                   ( xs )
# 346 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_08 =
  fun b ->
    (
# 151 "lib/menhir_parser.mly"
                    ( Component_value.Paren_block b )
# 354 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_09 =
  fun b ->
    (
# 152 "lib/menhir_parser.mly"
                      ( Component_value.Bracket_block b )
# 362 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_10 =
  fun n ->
    (
# 153 "lib/menhir_parser.mly"
                           ( Component_value.Percentage n )
# 370 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_11 =
  fun i ->
    (
# 154 "lib/menhir_parser.mly"
              ( Component_value.Ident i )
# 378 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_12 =
  fun s ->
    (
# 155 "lib/menhir_parser.mly"
               ( Component_value.String s )
# 386 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_13 =
  fun u ->
    (
# 156 "lib/menhir_parser.mly"
            ( Component_value.Uri u )
# 394 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_14 =
  fun o ->
    (
# 157 "lib/menhir_parser.mly"
                 ( Component_value.Operator o )
# 402 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_15 =
  fun d ->
    (
# 158 "lib/menhir_parser.mly"
              ( Component_value.Delim d )
# 410 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_16 =
  fun () ->
    (
# 159 "lib/menhir_parser.mly"
                              ( Component_value.Delim ":" )
# 418 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_17 =
  fun () ->
    (
# 160 "lib/menhir_parser.mly"
                            ( Component_value.Delim "." )
# 426 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_18 =
  fun _endpos_f_ _endpos_xs_ _startpos_f_ _startpos_xs_ f xs ->
    (
# 161 "lib/menhir_parser.mly"
                                                                   (
      Component_value.Function ((f, Lex_buffer.make_loc_and_fix _startpos_f_ _endpos_f_),
                                (xs, Lex_buffer.make_loc_and_fix _startpos_xs_ _endpos_xs_))
    )
# 437 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_19 =
  fun h ->
    (
# 165 "lib/menhir_parser.mly"
                                 ( Component_value.Hash h )
# 445 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_20 =
  fun n ->
    (
# 166 "lib/menhir_parser.mly"
               ( Component_value.Number n )
# 453 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_21 =
  fun r ->
    (
# 167 "lib/menhir_parser.mly"
                      ( Component_value.Unicode_range r )
# 461 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_22 =
  fun d ->
    (
# 168 "lib/menhir_parser.mly"
                        ( Component_value.Float_dimension d )
# 469 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_23 =
  fun d ->
    (
# 169 "lib/menhir_parser.mly"
                  ( Component_value.Dimension d )
# 477 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_24 =
  fun b ->
    (
# 176 "lib/menhir_parser.mly"
                    ( Component_value.Paren_block b )
# 485 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_25 =
  fun b ->
    (
# 177 "lib/menhir_parser.mly"
                      ( Component_value.Bracket_block b )
# 493 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_26 =
  fun n ->
    (
# 178 "lib/menhir_parser.mly"
                           ( Component_value.Percentage n )
# 501 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_27 =
  fun i ->
    (
# 179 "lib/menhir_parser.mly"
              ( Component_value.Ident i )
# 509 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_28 =
  fun s ->
    (
# 180 "lib/menhir_parser.mly"
               ( Component_value.String s )
# 517 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_29 =
  fun u ->
    (
# 181 "lib/menhir_parser.mly"
            ( Component_value.Uri u )
# 525 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_30 =
  fun o ->
    (
# 182 "lib/menhir_parser.mly"
                 ( Component_value.Operator o )
# 533 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_31 =
  fun d ->
    (
# 183 "lib/menhir_parser.mly"
              ( Component_value.Delim d )
# 541 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_32 =
  fun () ->
    (
# 184 "lib/menhir_parser.mly"
               ( Component_value.Delim "*" )
# 549 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_33 =
  fun () ->
    (
# 185 "lib/menhir_parser.mly"
          ( Component_value.Delim ":" )
# 557 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_34 =
  fun () ->
    (
# 186 "lib/menhir_parser.mly"
        ( Component_value.Delim "." )
# 565 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_35 =
  fun _endpos_f_ _endpos_xs_ _startpos_f_ _startpos_xs_ f xs ->
    (
# 187 "lib/menhir_parser.mly"
                                                                   (
      Component_value.Function ((f, Lex_buffer.make_loc_and_fix _startpos_f_ _endpos_f_),
                                (xs, Lex_buffer.make_loc_and_fix _startpos_xs_ _endpos_xs_))
    )
# 576 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_36 =
  fun h ->
    (
# 191 "lib/menhir_parser.mly"
             ( Component_value.Hash h )
# 584 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_37 =
  fun n ->
    (
# 192 "lib/menhir_parser.mly"
               ( Component_value.Number n )
# 592 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_38 =
  fun r ->
    (
# 193 "lib/menhir_parser.mly"
                      ( Component_value.Unicode_range r )
# 600 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_39 =
  fun d ->
    (
# 194 "lib/menhir_parser.mly"
                        ( Component_value.Float_dimension d )
# 608 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_40 =
  fun d ->
    (
# 195 "lib/menhir_parser.mly"
                  ( Component_value.Dimension d )
# 616 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_41 =
  fun _endpos_c_ _startpos_c_ c ->
    let _endpos = _endpos_c_ in
    let _startpos = _startpos_c_ in
    (
# 148 "lib/menhir_parser.mly"
                        ( (c, Lex_buffer.make_loc_and_fix _startpos _endpos) )
# 626 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc))

let _menhir_action_42 =
  fun _endpos_c_ _startpos_c_ c ->
    let _endpos = _endpos_c_ in
    let _startpos = _startpos_c_ in
    (
# 173 "lib/menhir_parser.mly"
                                   ( (c, Lex_buffer.make_loc_and_fix _startpos _endpos) )
# 636 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc))

let _menhir_action_43 =
  fun _endpos_i_ _endpos_n_ _endpos_v_ _startpos_i_ _startpos_n_ _startpos_v_ i n v ->
    let _endpos = _endpos_i_ in
    let _startpos = _startpos_n_ in
    (
# 130 "lib/menhir_parser.mly"
                                                                                                   (
    { Declaration.name = (n, Lex_buffer.make_loc_and_fix _startpos_n_ _endpos_n_);
      value = (v, Lex_buffer.make_loc_and_fix _startpos_v_ _endpos_v_);
      important = (i, Lex_buffer.make_loc_and_fix _startpos_i_ _endpos_i_);
      loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
    }
  )
# 652 "lib/menhir_parser.ml"
     : (Types.Declaration.t))

let _menhir_action_44 =
  fun ds ->
    (
# 55 "lib/menhir_parser.mly"
                                  ( ds )
# 660 "lib/menhir_parser.ml"
     : (Css__Types.Declaration_list.t))

let _menhir_action_45 =
  fun d ->
    (
# 125 "lib/menhir_parser.mly"
                    ( Declaration_list.Declaration d )
# 668 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind))

let _menhir_action_46 =
  fun r ->
    (
# 126 "lib/menhir_parser.mly"
                ( Declaration_list.At_rule r )
# 676 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind))

let _menhir_action_47 =
  fun ds ->
    (
# 115 "lib/menhir_parser.mly"
                                                ( List.rev ds )
# 684 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_48 =
  fun ds ->
    (
# 116 "lib/menhir_parser.mly"
                                                            ( List.rev ds )
# 692 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_49 =
  fun _endpos_ds_ _startpos_ds_ ds ->
    let _endpos = _endpos_ds_ in
    let _startpos = _startpos_ds_ in
    (
# 111 "lib/menhir_parser.mly"
                      ( (ds, Lex_buffer.make_loc_and_fix ~loc_ghost:true _startpos _endpos) )
# 702 "lib/menhir_parser.ml"
     : (Css__Types.Declaration_list.t))

let _menhir_action_50 =
  fun d ->
    (
# 120 "lib/menhir_parser.mly"
                               ( [d] )
# 710 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_51 =
  fun d ds ->
    (
# 121 "lib/menhir_parser.mly"
                                                                                        ( d :: ds )
# 718 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_52 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 726 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_53 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 734 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_54 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 742 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_55 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 750 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_56 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 758 "lib/menhir_parser.ml"
     : (Types.Rule.t list))

let _menhir_action_57 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 766 "lib/menhir_parser.ml"
     : (Types.Rule.t list))

let _menhir_action_58 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 774 "lib/menhir_parser.ml"
     : (unit option))

let _menhir_action_59 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 782 "lib/menhir_parser.ml"
     : (unit option))

let _menhir_action_60 =
  fun xs ->
    (
# 140 "lib/menhir_parser.mly"
                                                               ( xs )
# 790 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_61 =
  fun xs ->
    (
# 107 "lib/menhir_parser.mly"
                                                 ( xs )
# 798 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_62 =
  fun _endpos_xs_ _startpos_xs_ xs ->
    let _endpos = _endpos_xs_ in
    let _startpos = _startpos_xs_ in
    (
# 103 "lib/menhir_parser.mly"
               ( (xs, Lex_buffer.make_loc_and_fix _startpos _endpos) )
# 808 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list Types.with_loc))

let _menhir_action_63 =
  fun r ->
    (
# 59 "lib/menhir_parser.mly"
                ( Rule.At_rule r )
# 816 "lib/menhir_parser.ml"
     : (Types.Rule.t))

let _menhir_action_64 =
  fun r ->
    (
# 60 "lib/menhir_parser.mly"
                   ( Rule.Style_rule r )
# 824 "lib/menhir_parser.ml"
     : (Types.Rule.t))

let _menhir_action_65 =
  fun _endpos__3_ _startpos_xs_ xs ->
    let _endpos = _endpos__3_ in
    let _startpos = _startpos_xs_ in
    (
# 88 "lib/menhir_parser.mly"
                                                   (
      { Style_rule.prelude = xs;
        block = [], Location.none;
        loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
      }
    )
# 839 "lib/menhir_parser.ml"
     : (Types.Style_rule.t))

let _menhir_action_66 =
  fun _endpos__4_ _startpos_xs_ ds xs ->
    let _endpos = _endpos__4_ in
    let _startpos = _startpos_xs_ in
    (
# 94 "lib/menhir_parser.mly"
                                                                               (
      { Style_rule.prelude = xs;
        block = ds;
        loc = Lex_buffer.make_loc_and_fix _startpos _endpos;
      }
    )
# 854 "lib/menhir_parser.ml"
     : (Types.Style_rule.t))

let _menhir_action_67 =
  fun s ->
    (
# 47 "lib/menhir_parser.mly"
                                  ( s )
# 862 "lib/menhir_parser.ml"
     : (Types.Stylesheet.t))

let _menhir_action_68 =
  fun _endpos_rs_ _startpos_rs_ rs ->
    let _endpos = _endpos_rs_ in
    let _startpos = _startpos_rs_ in
    (
# 51 "lib/menhir_parser.mly"
                  ( (rs, Lex_buffer.make_loc_and_fix _startpos _endpos) )
# 872 "lib/menhir_parser.ml"
     : (Types.Stylesheet.t))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | WHITESPACE ->
        "WHITESPACE"
    | URI _ ->
        "URI"
    | UNICODE_RANGE _ ->
        "UNICODE_RANGE"
    | STRING _ ->
        "STRING"
    | SEMI_COLON ->
        "SEMI_COLON"
    | RIGHT_PAREN ->
        "RIGHT_PAREN"
    | RIGHT_BRACKET ->
        "RIGHT_BRACKET"
    | RIGHT_BRACE ->
        "RIGHT_BRACE"
    | PERCENTAGE ->
        "PERCENTAGE"
    | OPERATOR _ ->
        "OPERATOR"
    | NUMBER _ ->
        "NUMBER"
    | NESTED_AT_RULE _ ->
        "NESTED_AT_RULE"
    | LEFT_PAREN ->
        "LEFT_PAREN"
    | LEFT_BRACKET ->
        "LEFT_BRACKET"
    | LEFT_BRACE ->
        "LEFT_BRACE"
    | IMPORTANT ->
        "IMPORTANT"
    | IDENT _ ->
        "IDENT"
    | HASH _ ->
        "HASH"
    | FUNCTION _ ->
        "FUNCTION"
    | FLOAT_DIMENSION _ ->
        "FLOAT_DIMENSION"
    | EOF ->
        "EOF"
    | DOT ->
        "DOT"
    | DIMENSION _ ->
        "DIMENSION"
    | DELIM _ ->
        "DELIM"
    | COLON ->
        "COLON"
    | AT_RULE_WITHOUT_BODY _ ->
        "AT_RULE_WITHOUT_BODY"
    | AT_RULE _ ->
        "AT_RULE"

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_94 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_stylesheet =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let s = _v in
          let _v = _menhir_action_67 s in
          MenhirBox_stylesheet _v
      | _ ->
          _eRR ()
  
  let _menhir_run_90 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_declaration_list =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let ds = _v in
          let _v = _menhir_action_44 ds in
          MenhirBox_declaration_list _v
      | _ ->
          _eRR ()
  
  let rec _menhir_run_01 : 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_NESTED_AT_RULE (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | URI _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState01
      | UNICODE_RANGE _v_1 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState01
      | STRING _v_2 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState01
      | OPERATOR _v_3 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState01
      | NUMBER _v_4 ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState01
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | IDENT _v_5 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState01
      | HASH _v_6 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState01
      | FUNCTION _v_7 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState01
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState01
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | DIMENSION _v_9 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState01
      | DELIM _v_10 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState01
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | LEFT_BRACE ->
          let _v_11 = _menhir_action_54 () in
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState01 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_02 : 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_32 () in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_component_value_in_prelude : 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_c_, _startpos_c_, c) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_42 _endpos_c_ _startpos_c_ c in
      let _startpos = _startpos_c_ in
      let _menhir_stack = MenhirCell1_component_value_with_loc_in_prelude (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState56
      | URI _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState56
      | UNICODE_RANGE _v_1 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState56
      | STRING _v_2 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState56
      | OPERATOR _v_3 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState56
      | NUMBER _v_4 ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState56
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState56
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState56
      | IDENT _v_5 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState56
      | HASH _v_6 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState56
      | FUNCTION _v_7 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState56
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState56
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState56
      | DIMENSION _v_9 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState56
      | DELIM _v_10 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState56
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState56
      | LEFT_BRACE | SEMI_COLON ->
          let _v_11 = _menhir_action_54 () in
          _menhir_run_57 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_11 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_03 : 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_u_, _startpos_u_, u) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_29 u in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_u_ _startpos_u_ _v _menhir_s _tok
  
  and _menhir_run_04 : 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_r_, _startpos_r_, r) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_38 r in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_r_ _startpos_r_ _v _menhir_s _tok
  
  and _menhir_run_05 : 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_s_, _startpos_s_, s) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_28 s in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_06 : 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_o_, _startpos_o_, o) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_30 o in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_o_ _startpos_o_ _v _menhir_s _tok
  
  and _menhir_run_07 : 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
      | PERCENTAGE ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos_n_, n, _endpos__2_) = (_startpos, _v, _endpos_0) in
          let _v = _menhir_action_26 n in
          _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_n_ _v _menhir_s _tok
      | COLON | DELIM _ | DIMENSION _ | DOT | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | LEFT_BRACE | LEFT_BRACKET | LEFT_PAREN | NUMBER _ | OPERATOR _ | SEMI_COLON | STRING _ | UNICODE_RANGE _ | URI _ | WHITESPACE ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_37 n in
          _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_09 : 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 _menhir_stack = MenhirCell1_LEFT_PAREN (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | URI _v ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | UNICODE_RANGE _v ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | STRING _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | OPERATOR _v ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | NUMBER _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | IDENT _v ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | FUNCTION _v ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | FLOAT_DIMENSION _v ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | DIMENSION _v ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | DELIM _v ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | RIGHT_PAREN ->
          let _v = _menhir_action_52 () in
          _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | COLON | DOT | HASH _ ->
          let _ = _menhir_action_58 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState09 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_10 : 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
      let (_startpos_x_, x) = (_startpos, ()) in
      let _v = _menhir_action_59 x in
      _menhir_goto_option_WHITESPACE_ _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_option_WHITESPACE_ : 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 ->
      match _menhir_s with
      | MenhirState09 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState17 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState30 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState40 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState65 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok
      | MenhirState63 ->
          _menhir_run_64 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_24 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | HASH _v_0 ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos_h_, h) = (_startpos, _endpos, _v_0) in
          let _v = _menhir_action_19 h in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_h_ _startpos__1_ _v _menhir_s _tok
      | DOT ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos) in
          let _v = _menhir_action_17 () in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | COLON ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos) in
          let _v = _menhir_action_16 () in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_component_value : 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_c_, _startpos_c_, c) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_41 _endpos_c_ _startpos_c_ c in
      let _startpos = _startpos_c_ in
      let _menhir_stack = MenhirCell1_component_value_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | URI _v_0 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState30
      | UNICODE_RANGE _v_1 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState30
      | STRING _v_2 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState30
      | OPERATOR _v_3 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState30
      | NUMBER _v_4 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState30
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | IDENT _v_5 ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState30
      | FUNCTION _v_6 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState30
      | FLOAT_DIMENSION _v_7 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState30
      | DIMENSION _v_8 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState30
      | DELIM _v_9 ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState30
      | EOF | IMPORTANT | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SEMI_COLON ->
          let _v_10 = _menhir_action_52 () in
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_10 _tok
      | COLON | DOT | HASH _ ->
          let _ = _menhir_action_58 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState30 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_11 : 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_u_, _startpos_u_, u) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_13 u in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_u_ _startpos_u_ _v _menhir_s _tok
  
  and _menhir_run_12 : 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_r_, _startpos_r_, r) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_21 r in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_r_ _startpos_r_ _v _menhir_s _tok
  
  and _menhir_run_13 : 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_s_, _startpos_s_, s) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_12 s in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_14 : 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_o_, _startpos_o_, o) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_14 o in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_o_ _startpos_o_ _v _menhir_s _tok
  
  and _menhir_run_15 : 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
      | PERCENTAGE ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_startpos_n_, n, _endpos__2_) = (_startpos, _v, _endpos_0) in
          let _v = _menhir_action_10 n in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_n_ _v _menhir_s _tok
      | COLON | DELIM _ | DIMENSION _ | DOT | EOF | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | IMPORTANT | LEFT_BRACKET | LEFT_PAREN | NUMBER _ | OPERATOR _ | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SEMI_COLON | STRING _ | UNICODE_RANGE _ | URI _ | WHITESPACE ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_20 n in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_17 : 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 _menhir_stack = MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | URI _v ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | UNICODE_RANGE _v ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | STRING _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | OPERATOR _v ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | NUMBER _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState17
      | IDENT _v ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | FUNCTION _v ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | FLOAT_DIMENSION _v ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | DIMENSION _v ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | DELIM _v ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState17
      | RIGHT_BRACKET ->
          let _v = _menhir_action_52 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | COLON | DOT | HASH _ ->
          let _ = _menhir_action_58 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState17 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_18 : 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_i_, _startpos_i_, i) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_11 i in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok
  
  and _menhir_run_19 : 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_FUNCTION (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState19
      | URI _v_0 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState19
      | UNICODE_RANGE _v_1 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState19
      | STRING _v_2 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState19
      | OPERATOR _v_3 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState19
      | NUMBER _v_4 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState19
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState19
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState19
      | IDENT _v_5 ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState19
      | FUNCTION _v_6 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState19
      | FLOAT_DIMENSION _v_7 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState19
      | DIMENSION _v_8 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState19
      | DELIM _v_9 ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState19
      | RIGHT_PAREN ->
          let _v_10 = _menhir_action_52 () in
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_10 _tok
      | COLON | DOT | HASH _ ->
          let _ = _menhir_action_58 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState19 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_20 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_22 d in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_21 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_23 d in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_22 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_15 d in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_28 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_FUNCTION -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_FUNCTION (_menhir_stack, _menhir_s, f, _startpos_f_, _endpos_f_) = _menhir_stack in
          let (_endpos_xs_, _startpos_xs_, xs, _endpos__3_) = (_endpos, _startpos, _v, _endpos_0) in
          let _v = _menhir_action_18 _endpos_f_ _endpos_xs_ _startpos_f_ _startpos_xs_ f xs in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_f_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_34 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACKET ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (xs, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_07 xs in
          _menhir_goto_bracket_block _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_bracket_block : 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
      | MenhirState09 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState17 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState30 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState40 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState65 ->
          _menhir_run_33 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState50 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState56 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState60 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState81 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_33 : 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_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_09 b in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
  
  and _menhir_run_59 : 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_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_25 b in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
  
  and _menhir_run_31 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_component_value_with_loc -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_component_value_with_loc (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_53 x xs in
      _menhir_goto_list_component_value_with_loc_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_list_component_value_with_loc_ : 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
      | MenhirState19 ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | MenhirState30 ->
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState17 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState09 ->
          _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState40 ->
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | MenhirState65 ->
          _menhir_run_66 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_36 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_LEFT_PAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let (xs, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_60 xs in
          _menhir_goto_paren_block _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_paren_block : 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
      | MenhirState09 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState17 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState30 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState40 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState65 ->
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState50 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState56 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState60 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState81 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_54 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_23 : 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_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_08 b in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
  
  and _menhir_run_54 : 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_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_24 b in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
  
  and _menhir_run_41 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_FUNCTION -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_FUNCTION (_menhir_stack, _menhir_s, f, _startpos_f_, _endpos_f_) = _menhir_stack in
          let (_endpos_xs_, _startpos_xs_, xs, _endpos__3_) = (_endpos, _startpos, _v, _endpos_0) in
          let _v = _menhir_action_35 _endpos_f_ _endpos_xs_ _startpos_f_ _startpos_xs_ f xs in
          _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_f_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_66 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WHITESPACE_ _menhir_cell0_COLON 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_list_component_value_with_loc_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | IMPORTANT ->
          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__1_, _startpos__1_) = (_endpos_1, _startpos_0) in
          let _v = _menhir_action_06 () in
          _menhir_goto_boption_IMPORTANT_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _tok
      | EOF | RIGHT_BRACE | SEMI_COLON ->
          let _v = _menhir_action_05 () in
          _menhir_goto_boption_IMPORTANT_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_boption_IMPORTANT_ : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WHITESPACE_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_list_component_value_with_loc_ -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      let MenhirCell1_list_component_value_with_loc_ (_menhir_stack, _, v, _startpos_v_, _endpos_v_) = _menhir_stack in
      let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WHITESPACE_ (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _menhir_s, n, _startpos_n_, _endpos_n_) = _menhir_stack in
      let (_endpos_i_, _startpos_i_, i) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_43 _endpos_i_ _endpos_n_ _endpos_v_ _startpos_i_ _startpos_n_ _startpos_v_ i n v in
      let (_endpos, _startpos) = (_endpos_i_, _startpos_n_) in
      let (_endpos_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_45 d in
      _menhir_goto_declaration_or_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_goto_declaration_or_at_rule : 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
      | MenhirState70 ->
          _menhir_run_71 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState00 ->
          _menhir_run_77 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState62 ->
          _menhir_run_77 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState83 ->
          _menhir_run_77 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_71 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_declarations_without_ending_semi_colon _menhir_cell0_SEMI_COLON -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell0_SEMI_COLON (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_declarations_without_ending_semi_colon (_menhir_stack, _menhir_s, ds, _startpos_ds_, _) = _menhir_stack in
      let (_endpos_d_, d) = (_endpos, _v) in
      let _v = _menhir_action_51 d ds in
      _menhir_goto_declarations_without_ending_semi_colon _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_ds_ _v _menhir_s _tok
  
  and _menhir_goto_declarations_without_ending_semi_colon : 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
      | SEMI_COLON ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NESTED_AT_RULE _v_1 ->
              let _menhir_stack = MenhirCell1_declarations_without_ending_semi_colon (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_SEMI_COLON (_menhir_stack, _endpos_0) in
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState70
          | IDENT _v_2 ->
              let _menhir_stack = MenhirCell1_declarations_without_ending_semi_colon (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_SEMI_COLON (_menhir_stack, _endpos_0) in
              _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState70
          | AT_RULE_WITHOUT_BODY _v_3 ->
              let _menhir_stack = MenhirCell1_declarations_without_ending_semi_colon (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_SEMI_COLON (_menhir_stack, _endpos_0) in
              _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState70
          | AT_RULE _v_4 ->
              let _menhir_stack = MenhirCell1_declarations_without_ending_semi_colon (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
              let _menhir_stack = MenhirCell0_SEMI_COLON (_menhir_stack, _endpos_0) in
              _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState70
          | EOF | RIGHT_BRACE ->
              let (_endpos__2_, _startpos_ds_, ds) = (_endpos_0, _startpos, _v) in
              let _v = _menhir_action_48 ds in
              _menhir_goto_declarations _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_ds_ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | EOF | RIGHT_BRACE ->
          let (_endpos_ds_, _startpos_ds_, ds) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_47 ds in
          _menhir_goto_declarations _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_ds_ _startpos_ds_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_63 : 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_IDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState63
      | COLON ->
          let _v_0 = _menhir_action_58 () in
          _menhir_run_64 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState63 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_64 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_IDENT as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_WHITESPACE_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_0, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WHITESPACE ->
              _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState65
          | URI _v_1 ->
              _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState65
          | UNICODE_RANGE _v_2 ->
              _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState65
          | STRING _v_3 ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState65
          | OPERATOR _v_4 ->
              _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState65
          | NUMBER _v_5 ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState65
          | LEFT_PAREN ->
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState65
          | LEFT_BRACKET ->
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState65
          | IDENT _v_6 ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState65
          | FUNCTION _v_7 ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState65
          | FLOAT_DIMENSION _v_8 ->
              _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState65
          | DIMENSION _v_9 ->
              _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState65
          | DELIM _v_10 ->
              _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState65
          | EOF | IMPORTANT | RIGHT_BRACE | SEMI_COLON ->
              let _v_11 = _menhir_action_52 () in
              _menhir_run_66 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState65 _tok
          | COLON | DOT | HASH _ ->
              let _ = _menhir_action_58 () in
              _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState65 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_50 : 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_AT_RULE_WITHOUT_BODY (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | URI _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState50
      | UNICODE_RANGE _v_1 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState50
      | STRING _v_2 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState50
      | OPERATOR _v_3 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState50
      | NUMBER _v_4 ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState50
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | IDENT _v_5 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState50
      | HASH _v_6 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState50
      | FUNCTION _v_7 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState50
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState50
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | DIMENSION _v_9 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState50
      | DELIM _v_10 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState50
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState50
      | SEMI_COLON ->
          let _v_11 = _menhir_action_54 () in
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState50 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_38 : 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_i_, _startpos_i_, i) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_27 i in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok
  
  and _menhir_run_39 : 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_h_, _startpos_h_, h) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_36 h in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_h_ _startpos_h_ _v _menhir_s _tok
  
  and _menhir_run_40 : 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_FUNCTION (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState40
      | URI _v_0 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState40
      | UNICODE_RANGE _v_1 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState40
      | STRING _v_2 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState40
      | OPERATOR _v_3 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState40
      | NUMBER _v_4 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState40
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState40
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState40
      | IDENT _v_5 ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState40
      | FUNCTION _v_6 ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState40
      | FLOAT_DIMENSION _v_7 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState40
      | DIMENSION _v_8 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState40
      | DELIM _v_9 ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState40
      | RIGHT_PAREN ->
          let _v_10 = _menhir_action_52 () in
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_10 _tok
      | COLON | DOT | HASH _ ->
          let _ = _menhir_action_58 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos MenhirState40 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_43 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_39 d in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_44 : 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_34 () in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_45 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_40 d in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_46 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_31 d in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_47 : 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_33 () in
      _menhir_goto_component_value_in_prelude _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_55 : 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_xs_, _startpos_xs_, xs) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_61 xs in
      let (_endpos, _startpos) = (_endpos_xs_, _startpos_xs_) in
      let (_endpos_xs_, _startpos_xs_, xs) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_62 _endpos_xs_ _startpos_xs_ xs in
      _menhir_goto_prelude_with_loc _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_goto_prelude_with_loc : 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 ->
      match _menhir_s with
      | MenhirState01 ->
          _menhir_run_48 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState50 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState60 ->
          _menhir_run_61 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_82 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState81 ->
          _menhir_run_82 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_82 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_48 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_NESTED_AT_RULE as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WHITESPACE ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState49
          | URI _v_0 ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState49
          | UNICODE_RANGE _v_1 ->
              _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState49
          | STRING _v_2 ->
              _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState49
          | OPERATOR _v_3 ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState49
          | NUMBER _v_4 ->
              _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState49
          | NESTED_AT_RULE _v_5 ->
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState49
          | LEFT_PAREN ->
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState49
          | LEFT_BRACKET ->
              _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState49
          | IDENT _v_6 ->
              _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState49
          | HASH _v_7 ->
              _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState49
          | FUNCTION _v_8 ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState49
          | FLOAT_DIMENSION _v_9 ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState49
          | DOT ->
              _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState49
          | DIMENSION _v_10 ->
              _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState49
          | DELIM _v_11 ->
              _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState49
          | COLON ->
              _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState49
          | AT_RULE_WITHOUT_BODY _v_12 ->
              _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState49
          | AT_RULE _v_13 ->
              _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState49
          | LEFT_BRACE ->
              let _v_14 = _menhir_action_54 () in
              _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_14 MenhirState49 _tok
          | RIGHT_BRACE ->
              let _v_15 = _menhir_action_56 () in
              _menhir_run_89 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_15 MenhirState49 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_60 : 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_AT_RULE (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | URI _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState60
      | UNICODE_RANGE _v_1 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState60
      | STRING _v_2 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState60
      | OPERATOR _v_3 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState60
      | NUMBER _v_4 ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState60
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | IDENT _v_5 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState60
      | HASH _v_6 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState60
      | FUNCTION _v_7 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState60
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState60
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | DIMENSION _v_9 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState60
      | DELIM _v_10 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState60
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState60
      | LEFT_BRACE ->
          let _v_11 = _menhir_action_54 () in
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState60 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_89 : 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_rs_, _startpos_rs_, rs) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_68 _endpos_rs_ _startpos_rs_ rs in
      _menhir_goto_stylesheet_without_eof _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_stylesheet_without_eof : 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
      | MenhirState49 ->
          _menhir_run_78 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState93 ->
          _menhir_run_94 _menhir_stack _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_78 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_NESTED_AT_RULE, ttv_result) _menhir_cell1_prelude_with_loc -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_prelude_with_loc (_menhir_stack, _, xs, _) = _menhir_stack in
          let MenhirCell1_NESTED_AT_RULE (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let (s, _endpos__5_) = (_v, _endpos) in
          let _v = _menhir_action_03 _endpos__5_ _endpos_name_ _startpos_name_ name s xs in
          _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos_name_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_at_rule : 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
      | MenhirState00 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState62 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState70 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState83 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_88 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState81 ->
          _menhir_run_88 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_88 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_73 : 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_r_, _startpos_r_, r) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_46 r in
      _menhir_goto_declaration_or_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_r_ _startpos_r_ _v _menhir_s _tok
  
  and _menhir_run_88 : 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 (_startpos_r_, r) = (_startpos, _v) in
      let _v = _menhir_action_63 r in
      _menhir_goto_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_r_ _v _menhir_s _tok
  
  and _menhir_goto_rule : 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 _menhir_stack = MenhirCell1_rule (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState81
      | URI _v_0 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState81
      | UNICODE_RANGE _v_1 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState81
      | STRING _v_2 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState81
      | OPERATOR _v_3 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState81
      | NUMBER _v_4 ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState81
      | NESTED_AT_RULE _v_5 ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState81
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState81
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState81
      | IDENT _v_6 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState81
      | HASH _v_7 ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState81
      | FUNCTION _v_8 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState81
      | FLOAT_DIMENSION _v_9 ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState81
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState81
      | DIMENSION _v_10 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState81
      | DELIM _v_11 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState81
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState81
      | AT_RULE_WITHOUT_BODY _v_12 ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState81
      | AT_RULE _v_13 ->
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState81
      | LEFT_BRACE ->
          let _v_14 = _menhir_action_54 () in
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_14 MenhirState81 _tok
      | EOF | RIGHT_BRACE ->
          let _v_15 = _menhir_action_56 () in
          _menhir_run_87 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_15 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_87 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_rule -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_rule (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_57 x xs in
      _menhir_goto_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_list_rule_ : 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
      | MenhirState81 ->
          _menhir_run_87 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState49 ->
          _menhir_run_89 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_89 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_51 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_AT_RULE_WITHOUT_BODY -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | SEMI_COLON ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_AT_RULE_WITHOUT_BODY (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let (xs, _endpos__3_) = (_v, _endpos) in
          let _v = _menhir_action_02 _endpos__3_ _endpos_name_ _startpos_name_ name xs in
          _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_name_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_61 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_AT_RULE as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          let _menhir_s = MenhirState62 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NESTED_AT_RULE _v ->
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | AT_RULE_WITHOUT_BODY _v ->
              _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | AT_RULE _v ->
              _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_82 : 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 ->
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | RIGHT_BRACE ->
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_startpos_xs_, xs, _endpos__3_) = (_startpos, _v, _endpos) in
              let _v = _menhir_action_65 _endpos__3_ _startpos_xs_ xs in
              _menhir_goto_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_xs_ _v _menhir_s _tok
          | NESTED_AT_RULE _v_0 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState83
          | IDENT _v_1 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState83
          | AT_RULE_WITHOUT_BODY _v_2 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState83
          | AT_RULE _v_3 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState83
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_style_rule : 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 (_startpos_r_, r) = (_startpos, _v) in
      let _v = _menhir_action_64 r in
      _menhir_goto_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_r_ _v _menhir_s _tok
  
  and _menhir_goto_declarations : 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_ds_, _startpos_ds_, ds) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_49 _endpos_ds_ _startpos_ds_ ds in
      _menhir_goto_declarations_with_loc _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_declarations_with_loc : 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
      | MenhirState62 ->
          _menhir_run_74 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState83 ->
          _menhir_run_85 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState00 ->
          _menhir_run_90 _menhir_stack _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_74 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_AT_RULE, ttv_result) _menhir_cell1_prelude_with_loc -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_prelude_with_loc (_menhir_stack, _, xs, _) = _menhir_stack in
          let MenhirCell1_AT_RULE (_menhir_stack, _menhir_s, name, _startpos_name_, _endpos_name_) = _menhir_stack in
          let (_endpos__5_, ds) = (_endpos, _v) in
          let _v = _menhir_action_04 _endpos__5_ _endpos_name_ _startpos_name_ ds name xs in
          _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos_name_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_85 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_prelude_with_loc -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, xs, _startpos_xs_) = _menhir_stack in
          let (ds, _endpos__4_) = (_v, _endpos) in
          let _v = _menhir_action_66 _endpos__4_ _startpos_xs_ ds xs in
          _menhir_goto_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_xs_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_77 : 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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_50 d in
      _menhir_goto_declarations_without_ending_semi_colon _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_57 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_component_value_with_loc_in_prelude -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_component_value_with_loc_in_prelude (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_55 x xs in
      _menhir_goto_list_component_value_with_loc_in_prelude_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_list_component_value_with_loc_in_prelude_ : 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
      | MenhirState01 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState50 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState60 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState81 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState93 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState56 ->
          _menhir_run_57 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_declaration_list =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState00 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NESTED_AT_RULE _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | IDENT _v ->
          _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | AT_RULE_WITHOUT_BODY _v ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | AT_RULE _v ->
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  let _menhir_run_93 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_stylesheet =
    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
      | WHITESPACE ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState93
      | URI _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | UNICODE_RANGE _v ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | STRING _v ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | OPERATOR _v ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | NUMBER _v ->
          _menhir_run_07 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | NESTED_AT_RULE _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | LEFT_PAREN ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState93
      | LEFT_BRACKET ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState93
      | IDENT _v ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | HASH _v ->
          _menhir_run_39 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | FUNCTION _v ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | FLOAT_DIMENSION _v ->
          _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | DOT ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState93
      | DIMENSION _v ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | DELIM _v ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | COLON ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState93
      | AT_RULE_WITHOUT_BODY _v ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | AT_RULE _v ->
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState93
      | LEFT_BRACE ->
          let _v = _menhir_action_54 () in
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState93 _tok
      | EOF ->
          let _v = _menhir_action_56 () in
          _menhir_run_89 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState93 _tok
      | _ ->
          _eRR ()
  
end

let stylesheet =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_stylesheet v = _menhir_run_93 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let declaration_list =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_declaration_list v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v