Source file menhir_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | URI of (
# 23 "lib/menhir_parser.mly"
       (string)
# 15 "lib/menhir_parser.ml"
  )
    | UNICODE_RANGE of (
# 32 "lib/menhir_parser.mly"
       (string)
# 20 "lib/menhir_parser.ml"
  )
    | STRING of (
# 22 "lib/menhir_parser.mly"
       (string)
# 25 "lib/menhir_parser.ml"
  )
    | SEMI_COLON
    | RIGHT_PAREN
    | RIGHT_BRACKET
    | RIGHT_BRACE
    | PERCENTAGE
    | OPERATOR of (
# 24 "lib/menhir_parser.mly"
       (string)
# 35 "lib/menhir_parser.ml"
  )
    | NUMBER of (
# 31 "lib/menhir_parser.mly"
       (string)
# 40 "lib/menhir_parser.ml"
  )
    | NESTED_AT_RULE of (
# 26 "lib/menhir_parser.mly"
       (string)
# 45 "lib/menhir_parser.ml"
  )
    | LEFT_PAREN
    | LEFT_BRACKET
    | LEFT_BRACE
    | IMPORTANT
    | IDENT of (
# 21 "lib/menhir_parser.mly"
       (string)
# 54 "lib/menhir_parser.ml"
  )
    | HASH of (
# 30 "lib/menhir_parser.mly"
       (string)
# 59 "lib/menhir_parser.ml"
  )
    | FUNCTION of (
# 29 "lib/menhir_parser.mly"
       (string)
# 64 "lib/menhir_parser.ml"
  )
    | FLOAT_DIMENSION of (
# 33 "lib/menhir_parser.mly"
       (string * string * Types.dimension)
# 69 "lib/menhir_parser.ml"
  )
    | EOF
    | DIMENSION of (
# 34 "lib/menhir_parser.mly"
       (string * string)
# 75 "lib/menhir_parser.ml"
  )
    | DELIM of (
# 25 "lib/menhir_parser.mly"
       (string)
# 80 "lib/menhir_parser.ml"
  )
    | COLON
    | AT_RULE_WITHOUT_BODY of (
# 27 "lib/menhir_parser.mly"
       (string)
# 86 "lib/menhir_parser.ml"
  )
    | AT_RULE of (
# 28 "lib/menhir_parser.mly"
       (string)
# 91 "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


# 107 "lib/menhir_parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState00 : ('s, _menhir_box_declaration_list) _menhir_state
    (** State 00.
        Stack shape : .
        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>. *)

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

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

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

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

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

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

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

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

  | MenhirState39 : (('s, 'r) _menhir_cell1_IDENT _menhir_cell0_COLON, 'r) _menhir_state
    (** State 39.
        Stack shape : IDENT COLON.
        Start symbol: <undetermined>. *)

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

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

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

  | MenhirState67 : ('s, _menhir_box_stylesheet) _menhir_state
    (** State 67.
        Stack shape : .
        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_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_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 * (
# 28 "lib/menhir_parser.mly"
       (string)
# 205 "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 * (
# 27 "lib/menhir_parser.mly"
       (string)
# 212 "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 * (
# 29 "lib/menhir_parser.mly"
       (string)
# 222 "lib/menhir_parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_IDENT = 
  | MenhirCell1_IDENT of 's * ('s, 'r) _menhir_state * (
# 21 "lib/menhir_parser.mly"
       (string)
# 229 "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 * (
# 26 "lib/menhir_parser.mly"
       (string)
# 242 "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
    (
# 59 "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;
      }
    )
# 267 "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
    (
# 66 "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;
      }
    )
# 283 "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
    (
# 73 "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;
      }
    )
# 299 "lib/menhir_parser.ml"
     : (Types.At_rule.t))

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

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

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

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

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

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

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

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

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

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

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

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

let _menhir_action_17 =
  fun _endpos_f_ _endpos_xs_ _startpos_f_ _startpos_xs_ f xs ->
    (
# 155 "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_))
    )
# 406 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_18 =
  fun h ->
    (
# 159 "lib/menhir_parser.mly"
             ( Component_value.Hash h )
# 414 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_19 =
  fun n ->
    (
# 160 "lib/menhir_parser.mly"
               ( Component_value.Number n )
# 422 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_20 =
  fun r ->
    (
# 161 "lib/menhir_parser.mly"
                      ( Component_value.Unicode_range r )
# 430 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_21 =
  fun d ->
    (
# 162 "lib/menhir_parser.mly"
                        ( Component_value.Float_dimension d )
# 438 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

let _menhir_action_22 =
  fun d ->
    (
# 163 "lib/menhir_parser.mly"
                  ( Component_value.Dimension d )
# 446 "lib/menhir_parser.ml"
     : (Types.Component_value.t))

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

let _menhir_action_24 =
  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
    (
# 125 "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;
    }
  )
# 472 "lib/menhir_parser.ml"
     : (Types.Declaration.t))

let _menhir_action_25 =
  fun ds ->
    (
# 50 "lib/menhir_parser.mly"
                                  ( ds )
# 480 "lib/menhir_parser.ml"
     : (Css__Types.Declaration_list.t))

let _menhir_action_26 =
  fun d ->
    (
# 120 "lib/menhir_parser.mly"
                    ( Declaration_list.Declaration d )
# 488 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind))

let _menhir_action_27 =
  fun r ->
    (
# 121 "lib/menhir_parser.mly"
                ( Declaration_list.At_rule r )
# 496 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind))

let _menhir_action_28 =
  fun ds ->
    (
# 110 "lib/menhir_parser.mly"
                                                ( List.rev ds )
# 504 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_29 =
  fun ds ->
    (
# 111 "lib/menhir_parser.mly"
                                                            ( List.rev ds )
# 512 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

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

let _menhir_action_31 =
  fun d ->
    (
# 115 "lib/menhir_parser.mly"
                               ( [d] )
# 530 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

let _menhir_action_32 =
  fun d ds ->
    (
# 116 "lib/menhir_parser.mly"
                                                                                        ( d :: ds )
# 538 "lib/menhir_parser.ml"
     : (Types.Declaration_list.kind list))

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

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

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

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

let _menhir_action_37 =
  fun xs ->
    (
# 135 "lib/menhir_parser.mly"
                                                               ( xs )
# 578 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

let _menhir_action_38 =
  fun xs ->
    (
# 102 "lib/menhir_parser.mly"
                                      ( xs )
# 586 "lib/menhir_parser.ml"
     : (Types.Component_value.t Types.with_loc list))

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

let _menhir_action_40 =
  fun r ->
    (
# 54 "lib/menhir_parser.mly"
                ( Rule.At_rule r )
# 604 "lib/menhir_parser.ml"
     : (Types.Rule.t))

let _menhir_action_41 =
  fun r ->
    (
# 55 "lib/menhir_parser.mly"
                   ( Rule.Style_rule r )
# 612 "lib/menhir_parser.ml"
     : (Types.Rule.t))

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

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

let _menhir_action_44 =
  fun s ->
    (
# 42 "lib/menhir_parser.mly"
                                  ( s )
# 650 "lib/menhir_parser.ml"
     : (Types.Stylesheet.t))

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

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

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_68 : 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_44 s in
          MenhirBox_stylesheet _v
      | _ ->
          _eRR ()
  
  let _menhir_run_64 : 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_25 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
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState01
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState01
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState01
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState01
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState01
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | IDENT _v_5 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState01
      | HASH _v_6 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState01
      | FUNCTION _v_7 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState01
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState01
      | DIMENSION _v_9 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState01
      | DELIM _v_10 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState01
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState01
      | LEFT_BRACE ->
          let _v_11 = _menhir_action_33 () in
          _menhir_run_34 _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 _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_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_23 _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
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState20
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState20
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState20
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState20
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState20
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | IDENT _v_5 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState20
      | HASH _v_6 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState20
      | FUNCTION _v_7 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState20
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState20
      | DIMENSION _v_9 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState20
      | DELIM _v_10 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState20
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState20
      | EOF | IMPORTANT | LEFT_BRACE | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SEMI_COLON ->
          let _v_11 = _menhir_action_33 () in
          _menhir_run_21 _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_r_, _startpos_r_, r) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_20 r in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_r_ _startpos_r_ _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_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_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_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_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
      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 _ | EOF | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | IMPORTANT | LEFT_BRACE | LEFT_BRACKET | LEFT_PAREN | NUMBER _ | OPERATOR _ | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SEMI_COLON | STRING _ | UNICODE_RANGE _ | URI _ ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_19 n in
          _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_08 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _menhir_stack = MenhirCell1_LEFT_PAREN (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | URI _v ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | UNICODE_RANGE _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | STRING _v ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | OPERATOR _v ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | NUMBER _v ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState08
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState08
      | IDENT _v ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | HASH _v ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | FUNCTION _v ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | FLOAT_DIMENSION _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | DIMENSION _v ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | DELIM _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState08
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState08
      | RIGHT_PAREN ->
          let _v = _menhir_action_33 () in
          _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _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 _menhir_stack = MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | URI _v ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | UNICODE_RANGE _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | STRING _v ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | OPERATOR _v ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | NUMBER _v ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | IDENT _v ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | HASH _v ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | FUNCTION _v ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | FLOAT_DIMENSION _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | DIMENSION _v ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | DELIM _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState09
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState09
      | RIGHT_BRACKET ->
          let _v = _menhir_action_33 () in
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _v _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 _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_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_h_, _startpos_h_, h) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_18 h in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_h_ _startpos_h_ _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 _menhir_stack = MenhirCell1_FUNCTION (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState12
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState12
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState12
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState12
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState12
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState12
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState12
      | IDENT _v_5 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState12
      | HASH _v_6 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState12
      | FUNCTION _v_7 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState12
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState12
      | DIMENSION _v_9 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState12
      | DELIM _v_10 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState12
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState12
      | RIGHT_PAREN ->
          let _v_11 = _menhir_action_33 () in
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 _tok
      | _ ->
          _eRR ()
  
  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_d_, _startpos_d_, d) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_21 d in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _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_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_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
      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_16 : 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_16 () in
      _menhir_goto_component_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_18 : 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_17 _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_24 : 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
          let (_endpos, _startpos) = (_endpos__3_, _startpos__1_) in
          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
      | _ ->
          _eRR ()
  
  and _menhir_run_26 : 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_37 xs in
          let (_endpos, _startpos) = (_endpos__3_, _startpos__1_) in
          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
      | _ ->
          _eRR ()
  
  and _menhir_run_21 : 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_34 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
      | MenhirState39 ->
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState67 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState29 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState55 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState30 ->
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState08 ->
          _menhir_run_26 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState09 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState20 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState12 ->
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_40 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_IDENT _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 _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_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_24 _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_26 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
      | MenhirState00 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState57 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState44 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_51 : 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_31 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_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 MenhirState44
          | 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_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState44
          | 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_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState44
          | 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_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState44
          | EOF | RIGHT_BRACE ->
              let (_endpos__2_, _startpos_ds_, ds) = (_endpos_0, _startpos, _v) in
              let _v = _menhir_action_29 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_28 ds in
          _menhir_goto_declarations _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_ds_ _startpos_ds_ _v _menhir_s _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 _menhir_stack = MenhirCell1_IDENT (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COLON (_menhir_stack, _startpos_0, _endpos_1) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | URI _v_2 ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState39
          | UNICODE_RANGE _v_3 ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState39
          | STRING _v_4 ->
              _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState39
          | OPERATOR _v_5 ->
              _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState39
          | NUMBER _v_6 ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState39
          | LEFT_PAREN ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState39
          | LEFT_BRACKET ->
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState39
          | IDENT _v_7 ->
              _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState39
          | HASH _v_8 ->
              _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState39
          | FUNCTION _v_9 ->
              _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState39
          | FLOAT_DIMENSION _v_10 ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState39
          | DIMENSION _v_11 ->
              _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState39
          | DELIM _v_12 ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState39
          | COLON ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState39
          | EOF | IMPORTANT | RIGHT_BRACE | SEMI_COLON ->
              let _v_13 = _menhir_action_33 () in
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_13 MenhirState39 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_30 : 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
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState30
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState30
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState30
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState30
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState30
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | IDENT _v_5 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState30
      | HASH _v_6 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState30
      | FUNCTION _v_7 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState30
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState30
      | DIMENSION _v_9 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState30
      | DELIM _v_10 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState30
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState30
      | SEMI_COLON ->
          let _v_11 = _menhir_action_33 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState30 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_34 : 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_38 xs in
      let (_endpos, _startpos) = (_endpos_xs_, _startpos_xs_) in
      let (_endpos_xs_, _startpos_xs_, xs) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_39 _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
      | MenhirState67 ->
          _menhir_run_56 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState29 ->
          _menhir_run_56 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState55 ->
          _menhir_run_56 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState30 ->
          _menhir_run_31 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState01 ->
          _menhir_run_28 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_56 : 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_42 _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 MenhirState57
          | IDENT _v_1 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState57
          | AT_RULE_WITHOUT_BODY _v_2 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState57
          | AT_RULE _v_3 ->
              let _menhir_stack = MenhirCell1_prelude_with_loc (_menhir_stack, _menhir_s, _v, _startpos) in
              _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState57
          | _ ->
              _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_41 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
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState55
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState55
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState55
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState55
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState55
      | NESTED_AT_RULE _v_5 ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState55
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState55
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState55
      | IDENT _v_6 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState55
      | HASH _v_7 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState55
      | FUNCTION _v_8 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState55
      | FLOAT_DIMENSION _v_9 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState55
      | DIMENSION _v_10 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState55
      | DELIM _v_11 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState55
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState55
      | AT_RULE_WITHOUT_BODY _v_12 ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState55
      | AT_RULE _v_13 ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState55
      | LEFT_BRACE ->
          let _v_14 = _menhir_action_33 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_14 MenhirState55 _tok
      | EOF | RIGHT_BRACE ->
          let _v_15 = _menhir_action_35 () in
          _menhir_run_61 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_15 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_35 : 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
      | URI _v_0 ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState35
      | UNICODE_RANGE _v_1 ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState35
      | STRING _v_2 ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState35
      | OPERATOR _v_3 ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState35
      | NUMBER _v_4 ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState35
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState35
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState35
      | IDENT _v_5 ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState35
      | HASH _v_6 ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState35
      | FUNCTION _v_7 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState35
      | FLOAT_DIMENSION _v_8 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState35
      | DIMENSION _v_9 ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState35
      | DELIM _v_10 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState35
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState35
      | LEFT_BRACE ->
          let _v_11 = _menhir_action_33 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_11 MenhirState35 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_61 : 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_36 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
      | MenhirState67 ->
          _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState29 ->
          _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState55 ->
          _menhir_run_61 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  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 _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_rs_, _startpos_rs_, rs) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_45 _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
      | MenhirState67 ->
          _menhir_run_68 _menhir_stack _v _tok
      | MenhirState29 ->
          _menhir_run_52 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_52 : 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
      | MenhirState67 ->
          _menhir_run_62 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState29 ->
          _menhir_run_62 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState55 ->
          _menhir_run_62 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState00 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState57 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState44 ->
          _menhir_run_47 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_62 : 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_40 r in
      _menhir_goto_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_r_ _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 _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_r_, _startpos_r_, r) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_27 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_36 : 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 = MenhirState37 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_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | AT_RULE_WITHOUT_BODY _v ->
              _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | AT_RULE _v ->
              _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_31 : 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_28 : 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
          | URI _v_0 ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState29
          | UNICODE_RANGE _v_1 ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState29
          | STRING _v_2 ->
              _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState29
          | OPERATOR _v_3 ->
              _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState29
          | NUMBER _v_4 ->
              _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState29
          | NESTED_AT_RULE _v_5 ->
              _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState29
          | LEFT_PAREN ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState29
          | LEFT_BRACKET ->
              _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState29
          | IDENT _v_6 ->
              _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState29
          | HASH _v_7 ->
              _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState29
          | FUNCTION _v_8 ->
              _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState29
          | FLOAT_DIMENSION _v_9 ->
              _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState29
          | DIMENSION _v_10 ->
              _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState29
          | DELIM _v_11 ->
              _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState29
          | COLON ->
              _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState29
          | AT_RULE_WITHOUT_BODY _v_12 ->
              _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState29
          | AT_RULE _v_13 ->
              _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState29
          | LEFT_BRACE ->
              let _v_14 = _menhir_action_33 () in
              _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_14 MenhirState29 _tok
          | RIGHT_BRACE ->
              let _v_15 = _menhir_action_35 () in
              _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_15 MenhirState29 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  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_30 _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
      | MenhirState00 ->
          _menhir_run_64 _menhir_stack _v _tok
      | MenhirState57 ->
          _menhir_run_59 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState37 ->
          _menhir_run_48 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_59 : 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_43 _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_48 : 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_45 : 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_32 d ds in
      _menhir_goto_declarations_without_ending_semi_colon _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_ds_ _v _menhir_s _tok
  
  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_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | AT_RULE_WITHOUT_BODY _v ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | AT_RULE _v ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  let _menhir_run_67 : 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
      | URI _v ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | UNICODE_RANGE _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | STRING _v ->
          _menhir_run_04 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | OPERATOR _v ->
          _menhir_run_05 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | NUMBER _v ->
          _menhir_run_06 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | NESTED_AT_RULE _v ->
          _menhir_run_01 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | LEFT_PAREN ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState67
      | LEFT_BRACKET ->
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState67
      | IDENT _v ->
          _menhir_run_10 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | HASH _v ->
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | FUNCTION _v ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | FLOAT_DIMENSION _v ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | DIMENSION _v ->
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | DELIM _v ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | COLON ->
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState67
      | AT_RULE_WITHOUT_BODY _v ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | AT_RULE _v ->
          _menhir_run_35 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState67
      | LEFT_BRACE ->
          let _v = _menhir_action_33 () in
          _menhir_run_34 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState67 _tok
      | EOF ->
          let _v = _menhir_action_35 () in
          _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState67 _tok
      | _ ->
          _eRR ()
  
end

let stylesheet =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_stylesheet v = _menhir_run_67 _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