Source file css_parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | WS
    | URL of (
# 35 "packages/parser/lib/css_parser.mly"
       (string)
# 16 "packages/parser/lib/css_parser.ml"
  )
    | UNICODE_RANGE of (
# 49 "packages/parser/lib/css_parser.mly"
       (string)
# 21 "packages/parser/lib/css_parser.ml"
  )
    | TAG of (
# 28 "packages/parser/lib/css_parser.mly"
       (string)
# 26 "packages/parser/lib/css_parser.ml"
  )
    | STRING of (
# 29 "packages/parser/lib/css_parser.mly"
       (string)
# 31 "packages/parser/lib/css_parser.ml"
  )
    | SEMI_COLON
    | SCREEN_MEDIA_TYPE of (
# 41 "packages/parser/lib/css_parser.mly"
       (string)
# 37 "packages/parser/lib/css_parser.ml"
  )
    | RIGHT_PAREN
    | RIGHT_BRACKET
    | RIGHT_BRACE
    | PRINT_MEDIA_TYPE of (
# 42 "packages/parser/lib/css_parser.mly"
       (string)
# 45 "packages/parser/lib/css_parser.ml"
  )
    | PERCENT
    | OPERATOR of (
# 30 "packages/parser/lib/css_parser.mly"
       (string)
# 51 "packages/parser/lib/css_parser.ml"
  )
    | NUMBER of (
# 48 "packages/parser/lib/css_parser.mly"
       (string)
# 56 "packages/parser/lib/css_parser.ml"
  )
    | NTH_FUNCTION of (
# 34 "packages/parser/lib/css_parser.mly"
       (string)
# 61 "packages/parser/lib/css_parser.ml"
  )
    | MEDIA_QUERY_OPERATOR of (
# 38 "packages/parser/lib/css_parser.mly"
       (string)
# 66 "packages/parser/lib/css_parser.ml"
  )
    | MEDIA_FEATURE_COMPARISON of (
# 39 "packages/parser/lib/css_parser.mly"
       (string)
# 71 "packages/parser/lib/css_parser.ml"
  )
    | LEFT_PAREN
    | LEFT_BRACKET
    | LEFT_BRACE
    | INTERPOLATION of (
# 52 "packages/parser/lib/css_parser.mly"
       (string list)
# 79 "packages/parser/lib/css_parser.ml"
  )
    | IMPORTANT
    | IDENT of (
# 27 "packages/parser/lib/css_parser.mly"
       (string)
# 85 "packages/parser/lib/css_parser.ml"
  )
    | HASH of (
# 47 "packages/parser/lib/css_parser.mly"
       (string)
# 90 "packages/parser/lib/css_parser.ml"
  )
    | FUNCTION of (
# 33 "packages/parser/lib/css_parser.mly"
       (string)
# 95 "packages/parser/lib/css_parser.ml"
  )
    | FLOAT_DIMENSION of (
# 50 "packages/parser/lib/css_parser.mly"
       (string * string)
# 100 "packages/parser/lib/css_parser.ml"
  )
    | EQUAL_SIGN of (
# 37 "packages/parser/lib/css_parser.mly"
       (string)
# 105 "packages/parser/lib/css_parser.ml"
  )
    | EOF
    | DOUBLE_COLON
    | DOT
    | DIMENSION of (
# 51 "packages/parser/lib/css_parser.mly"
       (string * string)
# 113 "packages/parser/lib/css_parser.ml"
  )
    | DELIM of (
# 32 "packages/parser/lib/css_parser.mly"
       (string)
# 118 "packages/parser/lib/css_parser.ml"
  )
    | COMMA
    | COMBINATOR of (
# 31 "packages/parser/lib/css_parser.mly"
       (string)
# 124 "packages/parser/lib/css_parser.ml"
  )
    | COLON
    | BAD_URL
    | BAD_IDENT
    | AT_RULE_STATEMENT of (
# 46 "packages/parser/lib/css_parser.mly"
       (string)
# 132 "packages/parser/lib/css_parser.ml"
  )
    | AT_RULE of (
# 45 "packages/parser/lib/css_parser.mly"
       (string)
# 137 "packages/parser/lib/css_parser.ml"
  )
    | AT_MEDIA of (
# 40 "packages/parser/lib/css_parser.mly"
       (string)
# 142 "packages/parser/lib/css_parser.ml"
  )
    | AT_KEYFRAMES of (
# 44 "packages/parser/lib/css_parser.mly"
       (string)
# 147 "packages/parser/lib/css_parser.ml"
  )
    | ASTERISK
    | AMPERSAND
    | ALL_MEDIA_TYPE of (
# 43 "packages/parser/lib/css_parser.mly"
       (string)
# 154 "packages/parser/lib/css_parser.ml"
  )
  
end

include MenhirBasics

# 1 "packages/parser/lib/css_parser.mly"
  

open Ast

let make_loc = Parser_location.to_ppxlib_location


# 169 "packages/parser/lib/css_parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState000 : ('s, _menhir_box_declaration) _menhir_state
    (** State 000.
        Stack shape : .
        Start symbol: declaration. *)

  | MenhirState002 : (('s, _menhir_box_declaration) _menhir_cell1_skip_ws_left_declaration_without_eof_, _menhir_box_declaration) _menhir_state
    (** State 002.
        Stack shape : skip_ws_left(declaration_without_eof).
        Start symbol: declaration. *)

  | MenhirState005 : (('s, _menhir_box_declaration) _menhir_cell1_option_WS_, _menhir_box_declaration) _menhir_state
    (** State 005.
        Stack shape : option(WS).
        Start symbol: declaration. *)

  | MenhirState007 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_state
    (** State 007.
        Stack shape : option(WS) loc(IDENT).
        Start symbol: <undetermined>. *)

  | MenhirState009 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_state
    (** State 009.
        Stack shape : option(WS) loc(IDENT) option(WS) COLON.
        Start symbol: <undetermined>. *)

  | MenhirState010 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 010.
        Stack shape : option(WS) loc(IDENT) option(WS) COLON option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState013 : (('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 013.
        Stack shape : option(WS).
        Start symbol: <undetermined>. *)

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

  | MenhirState027 : (('s, 'r) _menhir_cell1_loc_skip_ws_value__, 'r) _menhir_state
    (** State 027.
        Stack shape : loc(skip_ws(value)).
        Start symbol: <undetermined>. *)

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

  | MenhirState046 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_value, 'r) _menhir_state
    (** State 046.
        Stack shape : option(WS) value.
        Start symbol: <undetermined>. *)

  | MenhirState050 : (('s, 'r) _menhir_cell1_loc_FUNCTION_, 'r) _menhir_state
    (** State 050.
        Stack shape : loc(FUNCTION).
        Start symbol: <undetermined>. *)

  | MenhirState054 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_values_, 'r) _menhir_state
    (** State 054.
        Stack shape : option(WS) loc(IDENT) option(WS) COLON option(WS) loc(values).
        Start symbol: <undetermined>. *)

  | MenhirState057 : ((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_values_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_loc_boption_IMPORTANT__, 'r) _menhir_state
    (** State 057.
        Stack shape : option(WS) loc(IDENT) option(WS) COLON option(WS) loc(values) option(WS) loc(boption(IMPORTANT)).
        Start symbol: <undetermined>. *)

  | MenhirState058 : (((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_IDENT_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_values_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_loc_boption_IMPORTANT__, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 058.
        Stack shape : option(WS) loc(IDENT) option(WS) COLON option(WS) loc(values) option(WS) loc(boption(IMPORTANT)) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState064 : ('s, _menhir_box_declaration_list) _menhir_state
    (** State 064.
        Stack shape : .
        Start symbol: declaration_list. *)

  | MenhirState065 : (('s, _menhir_box_declaration_list) _menhir_cell1_option_WS_, _menhir_box_declaration_list) _menhir_state
    (** State 065.
        Stack shape : option(WS).
        Start symbol: declaration_list. *)

  | MenhirState067 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_skip_ws_style_rule_, 'r) _menhir_state
    (** State 067.
        Stack shape : option(WS) skip_ws(style_rule).
        Start symbol: <undetermined>. *)

  | MenhirState068 : ((('s, 'r) _menhir_cell1_skip_ws_style_rule_, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_state
    (** State 068.
        Stack shape : skip_ws(style_rule) SEMI_COLON.
        Start symbol: <undetermined>. *)

  | MenhirState069 : ((('s, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_cell1_skip_ws_style_rule_, 'r) _menhir_state
    (** State 069.
        Stack shape : SEMI_COLON skip_ws(style_rule).
        Start symbol: <undetermined>. *)

  | MenhirState070 : ((('s, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_cell1_skip_ws_declaration_without_eof_, 'r) _menhir_state
    (** State 070.
        Stack shape : SEMI_COLON skip_ws(declaration_without_eof).
        Start symbol: <undetermined>. *)

  | MenhirState071 : ((('s, 'r) _menhir_cell1_skip_ws_declaration_without_eof_, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_state
    (** State 071.
        Stack shape : skip_ws(declaration_without_eof) SEMI_COLON.
        Start symbol: <undetermined>. *)

  | MenhirState072 : ((('s, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_cell1_skip_ws_at_rule_, 'r) _menhir_state
    (** State 072.
        Stack shape : SEMI_COLON skip_ws(at_rule).
        Start symbol: <undetermined>. *)

  | MenhirState073 : ((('s, 'r) _menhir_cell1_skip_ws_at_rule_, 'r) _menhir_cell1_SEMI_COLON, 'r) _menhir_state
    (** State 073.
        Stack shape : skip_ws(at_rule) SEMI_COLON.
        Start symbol: <undetermined>. *)

  | MenhirState075 : (('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 075.
        Stack shape : option(WS).
        Start symbol: <undetermined>. *)

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

  | MenhirState081 : ((('s, 'r) _menhir_cell1_LEFT_BRACKET, 'r) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, 'r) _menhir_state
    (** State 081.
        Stack shape : LEFT_BRACKET option(WS) wq_name.
        Start symbol: <undetermined>. *)

  | MenhirState086 : (((('s, 'r) _menhir_cell1_LEFT_BRACKET, 'r) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, 'r) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher, 'r) _menhir_state
    (** State 086.
        Stack shape : LEFT_BRACKET option(WS) wq_name option(WS) attr_matcher.
        Start symbol: <undetermined>. *)

  | MenhirState088 : ((((('s, 'r) _menhir_cell1_LEFT_BRACKET, 'r) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, 'r) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher, 'r) _menhir_cell1_option_WS_ _menhir_cell0_STRING, 'r) _menhir_state
    (** State 088.
        Stack shape : LEFT_BRACKET option(WS) wq_name option(WS) attr_matcher option(WS) STRING.
        Start symbol: <undetermined>. *)

  | MenhirState091 : ((((('s, 'r) _menhir_cell1_LEFT_BRACKET, 'r) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, 'r) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher, 'r) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 091.
        Stack shape : LEFT_BRACKET option(WS) wq_name option(WS) attr_matcher option(WS) IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState106 : (('s, 'r) _menhir_cell1_COLON _menhir_cell0_NTH_FUNCTION _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 106.
        Stack shape : COLON NTH_FUNCTION IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState110 : (('s, 'r) _menhir_cell1_COLON _menhir_cell0_NTH_FUNCTION _menhir_cell0_DIMENSION, 'r) _menhir_state
    (** State 110.
        Stack shape : COLON NTH_FUNCTION DIMENSION.
        Start symbol: <undetermined>. *)

  | MenhirState119 : (('s, 'r) _menhir_cell1_COLON _menhir_cell0_FUNCTION, 'r) _menhir_state
    (** State 119.
        Stack shape : COLON FUNCTION.
        Start symbol: <undetermined>. *)

  | MenhirState125 : (('s, 'r) _menhir_cell1_type_selector, 'r) _menhir_state
    (** State 125.
        Stack shape : type_selector.
        Start symbol: <undetermined>. *)

  | MenhirState126 : (('s, 'r) _menhir_cell1_subclass_selector, 'r) _menhir_state
    (** State 126.
        Stack shape : subclass_selector.
        Start symbol: <undetermined>. *)

  | MenhirState133 : (('s, 'r) _menhir_cell1_pseudo_element_selector, 'r) _menhir_state
    (** State 133.
        Stack shape : pseudo_element_selector.
        Start symbol: <undetermined>. *)

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

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

  | MenhirState141 : ((('s, 'r) _menhir_cell1_simple_selector, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 141.
        Stack shape : simple_selector option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState142 : (('s, 'r) _menhir_cell1_WS, 'r) _menhir_state
    (** State 142.
        Stack shape : WS.
        Start symbol: <undetermined>. *)

  | MenhirState145 : (('s, 'r) _menhir_cell1_nonempty_list_subclass_selector_, 'r) _menhir_state
    (** State 145.
        Stack shape : nonempty_list(subclass_selector).
        Start symbol: <undetermined>. *)

  | MenhirState148 : (('s, 'r) _menhir_cell1_simple_selector, 'r) _menhir_state
    (** State 148.
        Stack shape : simple_selector.
        Start symbol: <undetermined>. *)

  | MenhirState152 : (('s, 'r) _menhir_cell1_compound_selector, 'r) _menhir_state
    (** State 152.
        Stack shape : compound_selector.
        Start symbol: <undetermined>. *)

  | MenhirState154 : (('s, 'r) _menhir_cell1_combinator_sequence, 'r) _menhir_state
    (** State 154.
        Stack shape : combinator_sequence.
        Start symbol: <undetermined>. *)

  | MenhirState156 : (('s, 'r) _menhir_cell1_combinator, 'r) _menhir_state
    (** State 156.
        Stack shape : combinator.
        Start symbol: <undetermined>. *)

  | MenhirState157 : ((('s, 'r) _menhir_cell1_combinator, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 157.
        Stack shape : combinator option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState158 : (((('s, 'r) _menhir_cell1_combinator, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_simple_selector, 'r) _menhir_state
    (** State 158.
        Stack shape : combinator option(WS) simple_selector.
        Start symbol: <undetermined>. *)

  | MenhirState160 : (((('s, 'r) _menhir_cell1_combinator, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_compound_selector, 'r) _menhir_state
    (** State 160.
        Stack shape : combinator option(WS) compound_selector.
        Start symbol: <undetermined>. *)

  | MenhirState168 : (('s, 'r) _menhir_cell1_loc_selector_, 'r) _menhir_state
    (** State 168.
        Stack shape : loc(selector).
        Start symbol: <undetermined>. *)

  | MenhirState170 : ((('s, 'r) _menhir_cell1_loc_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_state
    (** State 170.
        Stack shape : loc(selector) option(WS) COMMA.
        Start symbol: <undetermined>. *)

  | MenhirState171 : (((('s, 'r) _menhir_cell1_loc_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 171.
        Stack shape : loc(selector) option(WS) COMMA option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState173 : ((((('s, 'r) _menhir_cell1_loc_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_selector_list, 'r) _menhir_state
    (** State 173.
        Stack shape : loc(selector) option(WS) COMMA option(WS) selector_list.
        Start symbol: <undetermined>. *)

  | MenhirState175 : (('s, 'r) _menhir_cell1_compound_selector, 'r) _menhir_state
    (** State 175.
        Stack shape : compound_selector.
        Start symbol: <undetermined>. *)

  | MenhirState176 : ((('s, 'r) _menhir_cell1_compound_selector, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 176.
        Stack shape : compound_selector option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState178 : (('s, 'r) _menhir_cell1_complex_selector, 'r) _menhir_state
    (** State 178.
        Stack shape : complex_selector.
        Start symbol: <undetermined>. *)

  | MenhirState182 : (('s, 'r) _menhir_cell1_loc_relative_selector_, 'r) _menhir_state
    (** State 182.
        Stack shape : loc(relative_selector).
        Start symbol: <undetermined>. *)

  | MenhirState184 : ((('s, 'r) _menhir_cell1_loc_relative_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_state
    (** State 184.
        Stack shape : loc(relative_selector) option(WS) COMMA.
        Start symbol: <undetermined>. *)

  | MenhirState185 : (((('s, 'r) _menhir_cell1_loc_relative_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 185.
        Stack shape : loc(relative_selector) option(WS) COMMA option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState187 : ((((('s, 'r) _menhir_cell1_loc_relative_selector_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_relative_selector_list, 'r) _menhir_state
    (** State 187.
        Stack shape : loc(relative_selector) option(WS) COMMA option(WS) relative_selector_list.
        Start symbol: <undetermined>. *)

  | MenhirState189 : (('s, 'r) _menhir_cell1_combinator, 'r) _menhir_state
    (** State 189.
        Stack shape : combinator.
        Start symbol: <undetermined>. *)

  | MenhirState190 : ((('s, 'r) _menhir_cell1_combinator, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 190.
        Stack shape : combinator option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState191 : (((('s, 'r) _menhir_cell1_combinator, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_complex_selector, 'r) _menhir_state
    (** State 191.
        Stack shape : combinator option(WS) complex_selector.
        Start symbol: <undetermined>. *)

  | MenhirState197 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_style_rule, 'r) _menhir_state
    (** State 197.
        Stack shape : option(WS) style_rule.
        Start symbol: <undetermined>. *)

  | MenhirState199 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_selector_list_, 'r) _menhir_state
    (** State 199.
        Stack shape : option(WS) loc(selector_list).
        Start symbol: <undetermined>. *)

  | MenhirState200 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_selector_list_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 200.
        Stack shape : option(WS) loc(selector_list) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState201 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_state
    (** State 201.
        Stack shape : option(WS) LEFT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState203 : ((('s, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 203.
        Stack shape : LEFT_BRACE option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState204 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_skip_ws_declaration_without_eof_, 'r) _menhir_state
    (** State 204.
        Stack shape : option(WS) skip_ws(declaration_without_eof).
        Start symbol: <undetermined>. *)

  | MenhirState205 : (('s, 'r) _menhir_cell1_skip_ws_style_rule_, 'r) _menhir_state
    (** State 205.
        Stack shape : skip_ws(style_rule).
        Start symbol: <undetermined>. *)

  | MenhirState206 : (('s, 'r) _menhir_cell1_skip_ws_declaration_without_eof_, 'r) _menhir_state
    (** State 206.
        Stack shape : skip_ws(declaration_without_eof).
        Start symbol: <undetermined>. *)

  | MenhirState207 : (('s, 'r) _menhir_cell1_skip_ws_at_rule_, 'r) _menhir_state
    (** State 207.
        Stack shape : skip_ws(at_rule).
        Start symbol: <undetermined>. *)

  | MenhirState211 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_skip_ws_at_rule_, 'r) _menhir_state
    (** State 211.
        Stack shape : option(WS) skip_ws(at_rule).
        Start symbol: <undetermined>. *)

  | MenhirState212 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_separated_nonempty_list_SEMI_COLON_rule_, 'r) _menhir_state
    (** State 212.
        Stack shape : option(WS) separated_nonempty_list(SEMI_COLON,rule).
        Start symbol: <undetermined>. *)

  | MenhirState214 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_nonempty_list_rule_, 'r) _menhir_state
    (** State 214.
        Stack shape : option(WS) nonempty_list(rule).
        Start symbol: <undetermined>. *)

  | MenhirState217 : ((('s, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_cell1_loc_declarations_ _menhir_cell0_RIGHT_BRACE, 'r) _menhir_state
    (** State 217.
        Stack shape : LEFT_BRACE loc(declarations) RIGHT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState223 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_STATEMENT_, 'r) _menhir_state
    (** State 223.
        Stack shape : option(WS) loc(AT_RULE_STATEMENT).
        Start symbol: <undetermined>. *)

  | MenhirState224 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_STATEMENT_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 224.
        Stack shape : option(WS) loc(AT_RULE_STATEMENT) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState227 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_STATEMENT_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_state
    (** State 227.
        Stack shape : option(WS) loc(AT_RULE_STATEMENT) option(WS) loc(prelude).
        Start symbol: <undetermined>. *)

  | MenhirState228 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_STATEMENT_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 228.
        Stack shape : option(WS) loc(AT_RULE_STATEMENT) option(WS) loc(prelude) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState230 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_state
    (** State 230.
        Stack shape : option(WS) loc(AT_RULE).
        Start symbol: <undetermined>. *)

  | MenhirState231 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 231.
        Stack shape : option(WS) loc(AT_RULE) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState232 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_state
    (** State 232.
        Stack shape : option(WS) loc(AT_RULE) option(WS) loc(prelude).
        Start symbol: <undetermined>. *)

  | MenhirState234 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_LEFT_BRACE, 'r) _menhir_state
    (** State 234.
        Stack shape : option(WS) loc(AT_RULE) option(WS) loc(prelude) option(WS) LEFT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState236 : ((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_LEFT_BRACE, 'r) _menhir_cell1_stylesheet_without_eof _menhir_cell0_RIGHT_BRACE, 'r) _menhir_state
    (** State 236.
        Stack shape : option(WS) loc(AT_RULE) option(WS) loc(prelude) option(WS) LEFT_BRACE stylesheet_without_eof RIGHT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState238 : (('s, 'r) _menhir_cell1_skip_ws_style_rule_, 'r) _menhir_state
    (** State 238.
        Stack shape : skip_ws(style_rule).
        Start symbol: <undetermined>. *)

  | MenhirState239 : (('s, 'r) _menhir_cell1_skip_ws_declaration_without_eof_, 'r) _menhir_state
    (** State 239.
        Stack shape : skip_ws(declaration_without_eof).
        Start symbol: <undetermined>. *)

  | MenhirState240 : (('s, 'r) _menhir_cell1_skip_ws_at_rule_, 'r) _menhir_state
    (** State 240.
        Stack shape : skip_ws(at_rule).
        Start symbol: <undetermined>. *)

  | MenhirState246 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_RULE_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_prelude_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_brace_block_stylesheet_without_eof_, 'r) _menhir_state
    (** State 246.
        Stack shape : option(WS) loc(AT_RULE) option(WS) loc(prelude) option(WS) brace_block(stylesheet_without_eof).
        Start symbol: <undetermined>. *)

  | MenhirState248 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_state
    (** State 248.
        Stack shape : option(WS) loc(AT_MEDIA).
        Start symbol: <undetermined>. *)

  | MenhirState249 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 249.
        Stack shape : option(WS) loc(AT_MEDIA) option(WS).
        Start symbol: <undetermined>. *)

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

  | MenhirState253 : ((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 253.
        Stack shape : LEFT_PAREN option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState258 : (((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_state
    (** State 258.
        Stack shape : LEFT_PAREN option(WS) IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState259 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_WS, 'r) _menhir_state
    (** State 259.
        Stack shape : LEFT_PAREN option(WS) IDENT WS.
        Start symbol: <undetermined>. *)

  | MenhirState265 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_WS, 'r) _menhir_cell1_mf_comparison _menhir_cell0_WS, 'r) _menhir_state
    (** State 265.
        Stack shape : LEFT_PAREN option(WS) IDENT WS mf_comparison WS.
        Start symbol: <undetermined>. *)

  | MenhirState269 : (('s, 'r) _menhir_cell1_less_than, 'r) _menhir_state
    (** State 269.
        Stack shape : less_than.
        Start symbol: <undetermined>. *)

  | MenhirState272 : (('s, 'r) _menhir_cell1_greater_than, 'r) _menhir_state
    (** State 272.
        Stack shape : greater_than.
        Start symbol: <undetermined>. *)

  | MenhirState276 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_state
    (** State 276.
        Stack shape : LEFT_PAREN option(WS) IDENT option(WS) COLON.
        Start symbol: <undetermined>. *)

  | MenhirState277 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COLON, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 277.
        Stack shape : LEFT_PAREN option(WS) IDENT option(WS) COLON option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState280 : (((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_state
    (** State 280.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type.
        Start symbol: <undetermined>. *)

  | MenhirState281 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_WS, 'r) _menhir_state
    (** State 281.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type WS.
        Start symbol: <undetermined>. *)

  | MenhirState283 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_WS, 'r) _menhir_cell1_option_and_media_condition_without_or_, 'r) _menhir_state
    (** State 283.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type WS option(and_media_condition_without_or).
        Start symbol: <undetermined>. *)

  | MenhirState285 : (('s, 'r) _menhir_cell1_and_operator, 'r) _menhir_state
    (** State 285.
        Stack shape : and_operator.
        Start symbol: <undetermined>. *)

  | MenhirState286 : (('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 286.
        Stack shape : option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState288 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_not_operator, 'r) _menhir_state
    (** State 288.
        Stack shape : option(WS) not_operator.
        Start symbol: <undetermined>. *)

  | MenhirState289 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_not_operator, 'r) _menhir_cell1_media_in_parens, 'r) _menhir_state
    (** State 289.
        Stack shape : option(WS) not_operator media_in_parens.
        Start symbol: <undetermined>. *)

  | MenhirState293 : ((('s, 'r) _menhir_cell1_and_operator, 'r) _menhir_cell1_media_in_parens, 'r) _menhir_state
    (** State 293.
        Stack shape : and_operator media_in_parens.
        Start symbol: <undetermined>. *)

  | MenhirState294 : (((('s, 'r) _menhir_cell1_and_operator, 'r) _menhir_cell1_media_in_parens, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 294.
        Stack shape : and_operator media_in_parens option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState296 : (('s, 'r) _menhir_cell1_media_and, 'r) _menhir_state
    (** State 296.
        Stack shape : media_and.
        Start symbol: <undetermined>. *)

  | MenhirState298 : (('s, 'r) _menhir_cell1_and_operator, 'r) _menhir_state
    (** State 298.
        Stack shape : and_operator.
        Start symbol: <undetermined>. *)

  | MenhirState303 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_state
    (** State 303.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type option(WS) COMMA.
        Start symbol: <undetermined>. *)

  | MenhirState304 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 304.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type option(WS) COMMA option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState306 : ((((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_state
    (** State 306.
        Stack shape : LEFT_PAREN option(WS) screen_or_print_media_type option(WS) COMMA option(WS) screen_or_print_media_type.
        Start symbol: <undetermined>. *)

  | MenhirState311 : (((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_mf_value _menhir_cell0_WS, 'r) _menhir_state
    (** State 311.
        Stack shape : LEFT_PAREN option(WS) mf_value WS.
        Start symbol: <undetermined>. *)

  | MenhirState315 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_mf_value _menhir_cell0_WS, 'r) _menhir_cell1_mf_lt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, 'r) _menhir_state
    (** State 315.
        Stack shape : LEFT_PAREN option(WS) mf_value WS mf_lt WS IDENT WS.
        Start symbol: <undetermined>. *)

  | MenhirState318 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_mf_value _menhir_cell0_WS, 'r) _menhir_cell1_mf_lt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, 'r) _menhir_cell1_mf_lt _menhir_cell0_WS, 'r) _menhir_state
    (** State 318.
        Stack shape : LEFT_PAREN option(WS) mf_value WS mf_lt WS IDENT WS mf_lt WS.
        Start symbol: <undetermined>. *)

  | MenhirState323 : ((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_mf_value _menhir_cell0_WS, 'r) _menhir_cell1_mf_gt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, 'r) _menhir_state
    (** State 323.
        Stack shape : LEFT_PAREN option(WS) mf_value WS mf_gt WS IDENT WS.
        Start symbol: <undetermined>. *)

  | MenhirState325 : (((((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_mf_value _menhir_cell0_WS, 'r) _menhir_cell1_mf_gt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, 'r) _menhir_cell1_mf_gt _menhir_cell0_WS, 'r) _menhir_state
    (** State 325.
        Stack shape : LEFT_PAREN option(WS) mf_value WS mf_gt WS IDENT WS mf_gt WS.
        Start symbol: <undetermined>. *)

  | MenhirState333 : (((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_media_feature, 'r) _menhir_state
    (** State 333.
        Stack shape : LEFT_PAREN option(WS) media_feature.
        Start symbol: <undetermined>. *)

  | MenhirState336 : (((('s, 'r) _menhir_cell1_LEFT_PAREN, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_all_media_type, 'r) _menhir_state
    (** State 336.
        Stack shape : LEFT_PAREN option(WS) all_media_type.
        Start symbol: <undetermined>. *)

  | MenhirState339 : (('s, 'r) _menhir_cell1_media_in_parens, 'r) _menhir_state
    (** State 339.
        Stack shape : media_in_parens.
        Start symbol: <undetermined>. *)

  | MenhirState340 : ((('s, 'r) _menhir_cell1_media_in_parens, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 340.
        Stack shape : media_in_parens option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState342 : (('s, 'r) _menhir_cell1_or_operator, 'r) _menhir_state
    (** State 342.
        Stack shape : or_operator.
        Start symbol: <undetermined>. *)

  | MenhirState345 : (('s, 'r) _menhir_cell1_media_or, 'r) _menhir_state
    (** State 345.
        Stack shape : media_or.
        Start symbol: <undetermined>. *)

  | MenhirState353 : (('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_state
    (** State 353.
        Stack shape : option(not_or_only).
        Start symbol: <undetermined>. *)

  | MenhirState355 : ((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_state
    (** State 355.
        Stack shape : option(not_or_only) screen_or_print_media_type.
        Start symbol: <undetermined>. *)

  | MenhirState356 : (((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 356.
        Stack shape : option(not_or_only) screen_or_print_media_type option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState358 : ((((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_state
    (** State 358.
        Stack shape : option(not_or_only) screen_or_print_media_type option(WS) option(COMMA).
        Start symbol: <undetermined>. *)

  | MenhirState359 : (((((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 359.
        Stack shape : option(not_or_only) screen_or_print_media_type option(WS) option(COMMA) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState360 : ((((((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_and_media_condition_without_or_, 'r) _menhir_state
    (** State 360.
        Stack shape : option(not_or_only) screen_or_print_media_type option(WS) option(COMMA) option(WS) option(and_media_condition_without_or).
        Start symbol: <undetermined>. *)

  | MenhirState361 : (((((((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_screen_or_print_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_and_media_condition_without_or_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_state
    (** State 361.
        Stack shape : option(not_or_only) screen_or_print_media_type option(WS) option(COMMA) option(WS) option(and_media_condition_without_or) option(COMMA).
        Start symbol: <undetermined>. *)

  | MenhirState363 : ((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_all_media_type, 'r) _menhir_state
    (** State 363.
        Stack shape : option(not_or_only) all_media_type.
        Start symbol: <undetermined>. *)

  | MenhirState364 : (((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_all_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 364.
        Stack shape : option(not_or_only) all_media_type option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState365 : ((((('s, 'r) _menhir_cell1_option_not_or_only_, 'r) _menhir_cell1_all_media_type, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_and_media_condition_without_or_, 'r) _menhir_state
    (** State 365.
        Stack shape : option(not_or_only) all_media_type option(WS) option(and_media_condition_without_or).
        Start symbol: <undetermined>. *)

  | MenhirState373 : (('s, 'r) _menhir_cell1_media_condition, 'r) _menhir_state
    (** State 373.
        Stack shape : media_condition.
        Start symbol: <undetermined>. *)

  | MenhirState374 : ((('s, 'r) _menhir_cell1_media_condition, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 374.
        Stack shape : media_condition option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState375 : (((('s, 'r) _menhir_cell1_media_condition, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_option_COMMA_, 'r) _menhir_state
    (** State 375.
        Stack shape : media_condition option(WS) option(COMMA).
        Start symbol: <undetermined>. *)

  | MenhirState377 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_media_query_prelude_, 'r) _menhir_state
    (** State 377.
        Stack shape : option(WS) loc(AT_MEDIA) option(WS) loc(media_query_prelude).
        Start symbol: <undetermined>. *)

  | MenhirState378 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_media_query_prelude_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 378.
        Stack shape : option(WS) loc(AT_MEDIA) option(WS) loc(media_query_prelude) option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState379 : ((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_media_query_prelude_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_empty_brace_block_, 'r) _menhir_state
    (** State 379.
        Stack shape : option(WS) loc(AT_MEDIA) option(WS) loc(media_query_prelude) option(WS) loc(empty_brace_block).
        Start symbol: <undetermined>. *)

  | MenhirState381 : ((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_MEDIA_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_media_query_prelude_, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_brace_block_loc_declarations__, 'r) _menhir_state
    (** State 381.
        Stack shape : option(WS) loc(AT_MEDIA) option(WS) loc(media_query_prelude) option(WS) brace_block(loc(declarations)).
        Start symbol: <undetermined>. *)

  | MenhirState383 : (('s, 'r) _menhir_cell1_loc_media_query_, 'r) _menhir_state
    (** State 383.
        Stack shape : loc(media_query).
        Start symbol: <undetermined>. *)

  | MenhirState385 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_KEYFRAMES_, 'r) _menhir_state
    (** State 385.
        Stack shape : option(WS) loc(AT_KEYFRAMES).
        Start symbol: <undetermined>. *)

  | MenhirState387 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_KEYFRAMES_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, 'r) _menhir_state
    (** State 387.
        Stack shape : option(WS) loc(AT_KEYFRAMES) option(WS) IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState388 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_KEYFRAMES_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 388.
        Stack shape : option(WS) loc(AT_KEYFRAMES) option(WS) IDENT option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState389 : (((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_KEYFRAMES_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_state
    (** State 389.
        Stack shape : option(WS) loc(AT_KEYFRAMES) option(WS) IDENT option(WS) LEFT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState391 : (('s, 'r) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA, 'r) _menhir_state
    (** State 391.
        Stack shape : skip_ws(percentage) COMMA.
        Start symbol: <undetermined>. *)

  | MenhirState393 : ((('s, 'r) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 393.
        Stack shape : skip_ws(percentage) COMMA option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState395 : (((('s, 'r) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_percentage, 'r) _menhir_state
    (** State 395.
        Stack shape : skip_ws(percentage) COMMA option(WS) percentage.
        Start symbol: <undetermined>. *)

  | MenhirState398 : (('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 398.
        Stack shape : option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState399 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_state
    (** State 399.
        Stack shape : option(WS) IDENT.
        Start symbol: <undetermined>. *)

  | MenhirState400 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 400.
        Stack shape : option(WS) IDENT option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState401 : (('s, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_state
    (** State 401.
        Stack shape : LEFT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState402 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_IDENT, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_brace_block_loc_declarations__, 'r) _menhir_state
    (** State 402.
        Stack shape : option(WS) IDENT option(WS) brace_block(loc(declarations)).
        Start symbol: <undetermined>. *)

  | MenhirState404 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_percentage, 'r) _menhir_state
    (** State 404.
        Stack shape : option(WS) percentage.
        Start symbol: <undetermined>. *)

  | MenhirState405 : (((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_percentage, 'r) _menhir_cell1_option_WS_, 'r) _menhir_state
    (** State 405.
        Stack shape : option(WS) percentage option(WS).
        Start symbol: <undetermined>. *)

  | MenhirState406 : ((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_percentage, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_brace_block_loc_declarations__, 'r) _menhir_state
    (** State 406.
        Stack shape : option(WS) percentage option(WS) brace_block(loc(declarations)).
        Start symbol: <undetermined>. *)

  | MenhirState409 : (('s, 'r) _menhir_cell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___, 'r) _menhir_state
    (** State 409.
        Stack shape : loption(separated_nonempty_list(COMMA,skip_ws(percentage))).
        Start symbol: <undetermined>. *)

  | MenhirState410 : ((('s, 'r) _menhir_cell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___, 'r) _menhir_cell1_brace_block_loc_declarations__, 'r) _menhir_state
    (** State 410.
        Stack shape : loption(separated_nonempty_list(COMMA,skip_ws(percentage))) brace_block(loc(declarations)).
        Start symbol: <undetermined>. *)

  | MenhirState412 : (('s, 'r) _menhir_cell1_keyframe_style_rule, 'r) _menhir_state
    (** State 412.
        Stack shape : keyframe_style_rule.
        Start symbol: <undetermined>. *)

  | MenhirState415 : ((((((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_loc_AT_KEYFRAMES_, 'r) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_LEFT_BRACE, 'r) _menhir_cell1_keyframe _menhir_cell0_RIGHT_BRACE, 'r) _menhir_state
    (** State 415.
        Stack shape : option(WS) loc(AT_KEYFRAMES) option(WS) IDENT option(WS) LEFT_BRACE keyframe RIGHT_BRACE.
        Start symbol: <undetermined>. *)

  | MenhirState419 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_declaration_without_eof, 'r) _menhir_state
    (** State 419.
        Stack shape : option(WS) declaration_without_eof.
        Start symbol: <undetermined>. *)

  | MenhirState421 : ((('s, 'r) _menhir_cell1_option_WS_, 'r) _menhir_cell1_at_rule, 'r) _menhir_state
    (** State 421.
        Stack shape : option(WS) at_rule.
        Start symbol: <undetermined>. *)

  | MenhirState428 : ('s, _menhir_box_keyframes) _menhir_state
    (** State 428.
        Stack shape : .
        Start symbol: keyframes. *)

  | MenhirState429 : (('s, _menhir_box_keyframes) _menhir_cell1_LEFT_BRACE, _menhir_box_keyframes) _menhir_state
    (** State 429.
        Stack shape : LEFT_BRACE.
        Start symbol: keyframes. *)

  | MenhirState431 : ((('s, _menhir_box_keyframes) _menhir_cell1_LEFT_BRACE, _menhir_box_keyframes) _menhir_cell1_loc_keyframe_ _menhir_cell0_RIGHT_BRACE, _menhir_box_keyframes) _menhir_state
    (** State 431.
        Stack shape : LEFT_BRACE loc(keyframe) RIGHT_BRACE.
        Start symbol: keyframes. *)

  | MenhirState439 : ('s, _menhir_box_stylesheet) _menhir_state
    (** State 439.
        Stack shape : .
        Start symbol: stylesheet. *)


and ('s, 'r) _menhir_cell1_all_media_type = 
  | MenhirCell1_all_media_type of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_and_operator = 
  | MenhirCell1_and_operator of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_at_rule = 
  | MenhirCell1_at_rule of 's * ('s, 'r) _menhir_state * (Ast.at_rule)

and 's _menhir_cell0_attr_matcher = 
  | MenhirCell0_attr_matcher of 's * (string)

and ('s, 'r) _menhir_cell1_brace_block_loc_declarations__ = 
  | MenhirCell1_brace_block_loc_declarations__ of 's * ('s, 'r) _menhir_state * (Ast.rule_list) * Lexing.position

and 's _menhir_cell0_brace_block_stylesheet_without_eof_ = 
  | MenhirCell0_brace_block_stylesheet_without_eof_ of 's * (Ast.stylesheet)

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

and ('s, 'r) _menhir_cell1_combinator_sequence = 
  | MenhirCell1_combinator_sequence of 's * ('s, 'r) _menhir_state * (string option * Ast.selector)

and ('s, 'r) _menhir_cell1_complex_selector = 
  | MenhirCell1_complex_selector of 's * ('s, 'r) _menhir_state * (Ast.complex_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_compound_selector = 
  | MenhirCell1_compound_selector of 's * ('s, 'r) _menhir_state * (Ast.compound_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_declaration_without_eof = 
  | MenhirCell1_declaration_without_eof of 's * ('s, 'r) _menhir_state * (Ast.declaration)

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

and ('s, 'r) _menhir_cell1_keyframe = 
  | MenhirCell1_keyframe of 's * ('s, 'r) _menhir_state * (Ast.rule list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_keyframe_style_rule = 
  | MenhirCell1_keyframe_style_rule of 's * ('s, 'r) _menhir_state * (Ast.rule) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_less_than = 
  | MenhirCell1_less_than of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_loc_AT_KEYFRAMES_ = 
  | MenhirCell1_loc_AT_KEYFRAMES_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_AT_MEDIA_ = 
  | MenhirCell1_loc_AT_MEDIA_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_AT_RULE_ = 
  | MenhirCell1_loc_AT_RULE_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_AT_RULE_STATEMENT_ = 
  | MenhirCell1_loc_AT_RULE_STATEMENT_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_FUNCTION_ = 
  | MenhirCell1_loc_FUNCTION_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_IDENT_ = 
  | MenhirCell1_loc_IDENT_ of 's * ('s, 'r) _menhir_state * (string Ast.with_loc) * Lexing.position

and 's _menhir_cell0_loc_boption_IMPORTANT__ = 
  | MenhirCell0_loc_boption_IMPORTANT__ of 's * (bool Ast.with_loc)

and ('s, 'r) _menhir_cell1_loc_declarations_ = 
  | MenhirCell1_loc_declarations_ of 's * ('s, 'r) _menhir_state * (Ast.rule_list)

and ('s, 'r) _menhir_cell1_loc_empty_brace_block_ = 
  | MenhirCell1_loc_empty_brace_block_ of 's * ('s, 'r) _menhir_state * (Ast.rule_list) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_keyframe_ = 
  | MenhirCell1_loc_keyframe_ of 's * ('s, 'r) _menhir_state * (Ast.rule_list)

and ('s, 'r) _menhir_cell1_loc_media_query_ = 
  | MenhirCell1_loc_media_query_ of 's * ('s, 'r) _menhir_state * (Ast.component_value Ast.with_loc) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_loc_media_query_prelude_ = 
  | MenhirCell1_loc_media_query_prelude_ of 's * ('s, 'r) _menhir_state * (Ast.component_value Ast.with_loc)

and ('s, 'r) _menhir_cell1_loc_prelude_ = 
  | MenhirCell1_loc_prelude_ of 's * ('s, 'r) _menhir_state * (Ast.component_value Ast.with_loc)

and ('s, 'r) _menhir_cell1_loc_relative_selector_ = 
  | MenhirCell1_loc_relative_selector_ of 's * ('s, 'r) _menhir_state * (Ast.selector Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_selector_ = 
  | MenhirCell1_loc_selector_ of 's * ('s, 'r) _menhir_state * (Ast.selector Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_selector_list_ = 
  | MenhirCell1_loc_selector_list_ of 's * ('s, 'r) _menhir_state * (Ast.selector_list Ast.with_loc) * Lexing.position

and ('s, 'r) _menhir_cell1_loc_skip_ws_value__ = 
  | MenhirCell1_loc_skip_ws_value__ of 's * ('s, 'r) _menhir_state * (Ast.component_value Ast.with_loc) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_loc_values_ = 
  | MenhirCell1_loc_values_ of 's * ('s, 'r) _menhir_state * (Ast.component_value_list Ast.with_loc)

and ('s, 'r) _menhir_cell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ = 
  | MenhirCell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ of 's * ('s, 'r) _menhir_state * (string list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_media_and = 
  | MenhirCell1_media_and of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_media_condition = 
  | MenhirCell1_media_condition of 's * ('s, 'r) _menhir_state * (Ast.component_value) * Lexing.position

and ('s, 'r) _menhir_cell1_media_feature = 
  | MenhirCell1_media_feature of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_media_in_parens = 
  | MenhirCell1_media_in_parens of 's * ('s, 'r) _menhir_state * (Ast.component_value) * Lexing.position

and ('s, 'r) _menhir_cell1_media_or = 
  | MenhirCell1_media_or of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_mf_comparison = 
  | MenhirCell1_mf_comparison of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_mf_gt = 
  | MenhirCell1_mf_gt of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_mf_lt = 
  | MenhirCell1_mf_lt of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_mf_value = 
  | MenhirCell1_mf_value of 's * ('s, 'r) _menhir_state * (Ast.component_value)

and ('s, 'r) _menhir_cell1_nonempty_list_rule_ = 
  | MenhirCell1_nonempty_list_rule_ of 's * ('s, 'r) _menhir_state * (Ast.rule list)

and ('s, 'r) _menhir_cell1_nonempty_list_subclass_selector_ = 
  | MenhirCell1_nonempty_list_subclass_selector_ of 's * ('s, 'r) _menhir_state * (Ast.subclass_selector list) * Lexing.position

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

and ('s, 'r) _menhir_cell1_option_COMMA_ = 
  | MenhirCell1_option_COMMA_ of 's * ('s, 'r) _menhir_state * (unit option)

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

and ('s, 'r) _menhir_cell1_option_and_media_condition_without_or_ = 
  | MenhirCell1_option_and_media_condition_without_or_ of 's * ('s, 'r) _menhir_state * (Ast.component_value option)

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

and ('s, 'r) _menhir_cell1_or_operator = 
  | MenhirCell1_or_operator of 's * ('s, 'r) _menhir_state * (string)

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

and ('s, 'r) _menhir_cell1_pseudo_class_selector = 
  | MenhirCell1_pseudo_class_selector of 's * ('s, 'r) _menhir_state * (Ast.pseudo_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_pseudo_element_selector = 
  | MenhirCell1_pseudo_element_selector of 's * ('s, 'r) _menhir_state * (Ast.pseudo_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_relative_selector_list = 
  | MenhirCell1_relative_selector_list of 's * ('s, 'r) _menhir_state * (Ast.selector_list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_screen_or_print_media_type = 
  | MenhirCell1_screen_or_print_media_type of 's * ('s, 'r) _menhir_state * (string)

and ('s, 'r) _menhir_cell1_selector_list = 
  | MenhirCell1_selector_list of 's * ('s, 'r) _menhir_state * (Ast.selector_list) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_separated_nonempty_list_SEMI_COLON_rule_ = 
  | MenhirCell1_separated_nonempty_list_SEMI_COLON_rule_ of 's * ('s, 'r) _menhir_state * (Ast.rule list)

and ('s, 'r) _menhir_cell1_simple_selector = 
  | MenhirCell1_simple_selector of 's * ('s, 'r) _menhir_state * (Ast.simple_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_skip_ws_at_rule_ = 
  | MenhirCell1_skip_ws_at_rule_ of 's * ('s, 'r) _menhir_state * (Ast.at_rule) * Lexing.position

and ('s, 'r) _menhir_cell1_skip_ws_declaration_without_eof_ = 
  | MenhirCell1_skip_ws_declaration_without_eof_ of 's * ('s, 'r) _menhir_state * (Ast.declaration) * Lexing.position

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

and ('s, 'r) _menhir_cell1_skip_ws_style_rule_ = 
  | MenhirCell1_skip_ws_style_rule_ of 's * ('s, 'r) _menhir_state * (Ast.style_rule) * Lexing.position

and ('s, 'r) _menhir_cell1_skip_ws_left_declaration_without_eof_ = 
  | MenhirCell1_skip_ws_left_declaration_without_eof_ of 's * ('s, 'r) _menhir_state * (Ast.declaration)

and ('s, 'r) _menhir_cell1_style_rule = 
  | MenhirCell1_style_rule of 's * ('s, 'r) _menhir_state * (Ast.style_rule)

and ('s, 'r) _menhir_cell1_stylesheet_without_eof = 
  | MenhirCell1_stylesheet_without_eof of 's * ('s, 'r) _menhir_state * (Ast.stylesheet)

and ('s, 'r) _menhir_cell1_subclass_selector = 
  | MenhirCell1_subclass_selector of 's * ('s, 'r) _menhir_state * (Ast.subclass_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_type_selector = 
  | MenhirCell1_type_selector of 's * ('s, 'r) _menhir_state * (Ast.simple_selector) * Lexing.position

and ('s, 'r) _menhir_cell1_value = 
  | MenhirCell1_value of 's * ('s, 'r) _menhir_state * (Ast.component_value) * Lexing.position * Lexing.position

and 's _menhir_cell0_wq_name = 
  | MenhirCell0_wq_name of 's * (string)

and ('s, 'r) _menhir_cell1_COLON = 
  | MenhirCell1_COLON of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position

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

and 's _menhir_cell0_COMMA = 
  | MenhirCell0_COMMA of 's * Lexing.position * Lexing.position

and 's _menhir_cell0_DIMENSION = 
  | MenhirCell0_DIMENSION of 's * (
# 51 "packages/parser/lib/css_parser.mly"
       (string * string)
# 1231 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_FUNCTION = 
  | MenhirCell0_FUNCTION of 's * (
# 33 "packages/parser/lib/css_parser.mly"
       (string)
# 1238 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_IDENT = 
  | MenhirCell1_IDENT of 's * ('s, 'r) _menhir_state * (
# 27 "packages/parser/lib/css_parser.mly"
       (string)
# 1245 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_IDENT = 
  | MenhirCell0_IDENT of 's * (
# 27 "packages/parser/lib/css_parser.mly"
       (string)
# 1252 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_LEFT_BRACE = 
  | MenhirCell1_LEFT_BRACE of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_LEFT_BRACE = 
  | MenhirCell0_LEFT_BRACE of 's * 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 _menhir_cell0_NTH_FUNCTION = 
  | MenhirCell0_NTH_FUNCTION of 's * (
# 34 "packages/parser/lib/css_parser.mly"
       (string)
# 1271 "packages/parser/lib/css_parser.ml"
)

and ('s, 'r) _menhir_cell1_NUMBER = 
  | MenhirCell1_NUMBER of 's * ('s, 'r) _menhir_state * (
# 48 "packages/parser/lib/css_parser.mly"
       (string)
# 1278 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and 's _menhir_cell0_RIGHT_BRACE = 
  | MenhirCell0_RIGHT_BRACE of 's * Lexing.position

and ('s, 'r) _menhir_cell1_SEMI_COLON = 
  | MenhirCell1_SEMI_COLON of 's * ('s, 'r) _menhir_state * Lexing.position

and 's _menhir_cell0_STRING = 
  | MenhirCell0_STRING of 's * (
# 29 "packages/parser/lib/css_parser.mly"
       (string)
# 1291 "packages/parser/lib/css_parser.ml"
) * Lexing.position * Lexing.position

and ('s, 'r) _menhir_cell1_WS = 
  | MenhirCell1_WS of 's * ('s, 'r) _menhir_state * Lexing.position * Lexing.position

and 's _menhir_cell0_WS = 
  | MenhirCell0_WS of 's * Lexing.position * Lexing.position

and _menhir_box_stylesheet = 
  | MenhirBox_stylesheet of (Ast.stylesheet) [@@unboxed]

and _menhir_box_keyframes = 
  | MenhirBox_keyframes of (Ast.rule_list) [@@unboxed]

and _menhir_box_declaration_list = 
  | MenhirBox_declaration_list of (Ast.rule_list) [@@unboxed]

and _menhir_box_declaration = 
  | MenhirBox_declaration of (Ast.declaration) [@@unboxed]

let _menhir_action_004 =
  fun amt ->
    (
# 120 "packages/parser/lib/css_parser.mly"
                                     ( amt )
# 1317 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_005 =
  fun xs ->
    (
# 228 "packages/parser/lib/css_parser.mly"
                                                                             ( Ident xs )
# 1325 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_006 =
  fun a ->
    (
# 108 "packages/parser/lib/css_parser.mly"
                                       ( a )
# 1333 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_007 =
  fun _endpos__6_ _startpos_name_ ds name prelude ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos_name_ in
    (
# 248 "packages/parser/lib/css_parser.mly"
                                            (
    { name;
      prelude;
      block = Rule_list ds;
      loc = make_loc _startpos _endpos;
    }
  )
# 1349 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_008 =
  fun _endpos__6_ _startpos_name_ b name prelude ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos_name_ in
    (
# 258 "packages/parser/lib/css_parser.mly"
                                   (
    { name;
      prelude;
      block = Rule_list b;
      loc = make_loc _startpos _endpos;
    }
  )
# 1365 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_009 =
  fun _endpos_block_ _endpos_i_ _startpos_i_ _startpos_name_ block i name ->
    let _endpos = _endpos_block_ in
    let _startpos = _startpos_name_ in
    (
# 268 "packages/parser/lib/css_parser.mly"
                                  (
    let prelude = (Ident i, make_loc _startpos_i_ _endpos_i_) in
    let block = Rule_list (block, make_loc _startpos _endpos) in
    { name;
      prelude;
      block;
      loc = make_loc _startpos _endpos;
    }
  )
# 1383 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_010 =
  fun _endpos_i_ _endpos_s_ _startpos_i_ _startpos_name_ i name s ->
    let _endpos = _endpos_s_ in
    let _startpos = _startpos_name_ in
    (
# 280 "packages/parser/lib/css_parser.mly"
                               (
    let prelude = ((Ident i), make_loc _startpos_i_ _endpos_i_) in
    let empty_block = Rule_list s in
    ({ name;
      prelude;
      block = empty_block;
      loc = make_loc _startpos _endpos;
    }): at_rule
  )
# 1401 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_011 =
  fun _endpos__5_ _startpos_name_ name xs ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos_name_ in
    (
# 291 "packages/parser/lib/css_parser.mly"
                                      (
    { name;
      prelude = xs;
      block = Empty;
      loc = make_loc _startpos _endpos;
    }
  )
# 1417 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_012 =
  fun _endpos__6_ _startpos_name_ name s xs ->
    let _endpos = _endpos__6_ in
    let _startpos = _startpos_name_ in
    (
# 303 "packages/parser/lib/css_parser.mly"
                                                (
    { name;
      prelude = xs;
      block = Stylesheet s;
      loc = make_loc _startpos _endpos;
    }
  )
# 1433 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_013 =
  fun o ->
    (
# 466 "packages/parser/lib/css_parser.mly"
                ( o )
# 1441 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_014 =
  fun eq ->
    (
# 467 "packages/parser/lib/css_parser.mly"
                   ( eq )
# 1449 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_015 =
  fun i ->
    (
# 480 "packages/parser/lib/css_parser.mly"
                  (
    Attribute(Attr_value i)
  )
# 1459 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_016 =
  fun i m v ->
    (
# 488 "packages/parser/lib/css_parser.mly"
                  (
    Attribute(
      To_equal({
        name = i;
        kind = m;
        value = Attr_string v
      })
    )
  )
# 1475 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_017 =
  fun i m v ->
    (
# 502 "packages/parser/lib/css_parser.mly"
                  (
    Attribute(
      To_equal({
        name = i;
        kind = m;
        value = Attr_ident v
      })
    )
  )
# 1491 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_018 =
  fun () ->
    (
# 134 "<standard.mly>"
    ( false )
# 1499 "packages/parser/lib/css_parser.ml"
     : (bool))

let _menhir_action_019 =
  fun () ->
    (
# 137 "<standard.mly>"
    ( true )
# 1507 "packages/parser/lib/css_parser.ml"
     : (bool))

let _menhir_action_020 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 1515 "packages/parser/lib/css_parser.ml"
     in
    (
# 91 "packages/parser/lib/css_parser.mly"
                                                                       ( xs )
# 1520 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_021 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 1528 "packages/parser/lib/css_parser.ml"
     in
    (
# 91 "packages/parser/lib/css_parser.mly"
                                                                       ( xs )
# 1533 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_022 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 1541 "packages/parser/lib/css_parser.ml"
     in
    (
# 91 "packages/parser/lib/css_parser.mly"
                                                                       ( xs )
# 1546 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_023 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 1554 "packages/parser/lib/css_parser.ml"
     in
    (
# 91 "packages/parser/lib/css_parser.mly"
                                                                       ( xs )
# 1559 "packages/parser/lib/css_parser.ml"
     : (Ast.stylesheet))

let _menhir_action_024 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 1567 "packages/parser/lib/css_parser.ml"
     in
    (
# 94 "packages/parser/lib/css_parser.mly"
                                                                  ( xs )
# 1572 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_025 =
  fun id ->
    (
# 519 "packages/parser/lib/css_parser.mly"
                   ( Class id )
# 1580 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_026 =
  fun tag ->
    (
# 521 "packages/parser/lib/css_parser.mly"
                  ( Class tag )
# 1588 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_027 =
  fun c ->
    (
# 406 "packages/parser/lib/css_parser.mly"
                   ( c )
# 1596 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_028 =
  fun c ->
    (
# 407 "packages/parser/lib/css_parser.mly"
                     ( c )
# 1604 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_029 =
  fun s ->
    let s = 
# 625 "packages/parser/lib/css_parser.mly"
                        ( SimpleSelector s )
# 1612 "packages/parser/lib/css_parser.ml"
     in
    (
# 620 "packages/parser/lib/css_parser.mly"
                                ( (None, s) )
# 1617 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_030 =
  fun s ->
    let s = 
# 626 "packages/parser/lib/css_parser.mly"
                          ( CompoundSelector s )
# 1625 "packages/parser/lib/css_parser.ml"
     in
    (
# 620 "packages/parser/lib/css_parser.mly"
                                ( (None, s) )
# 1630 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_031 =
  fun s ->
    let s = 
# 625 "packages/parser/lib/css_parser.mly"
                        ( SimpleSelector s )
# 1638 "packages/parser/lib/css_parser.ml"
     in
    (
# 621 "packages/parser/lib/css_parser.mly"
                                 ( (None, s) )
# 1643 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_032 =
  fun s ->
    let s = 
# 626 "packages/parser/lib/css_parser.mly"
                          ( CompoundSelector s )
# 1651 "packages/parser/lib/css_parser.ml"
     in
    (
# 621 "packages/parser/lib/css_parser.mly"
                                 ( (None, s) )
# 1656 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_033 =
  fun c s ->
    let s = 
# 625 "packages/parser/lib/css_parser.mly"
                        ( SimpleSelector s )
# 1664 "packages/parser/lib/css_parser.ml"
     in
    (
# 622 "packages/parser/lib/css_parser.mly"
                                                    ( (Some c, s) )
# 1669 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_034 =
  fun c s ->
    let s = 
# 626 "packages/parser/lib/css_parser.mly"
                          ( CompoundSelector s )
# 1677 "packages/parser/lib/css_parser.ml"
     in
    (
# 622 "packages/parser/lib/css_parser.mly"
                                                    ( (Some c, s) )
# 1682 "packages/parser/lib/css_parser.ml"
     : (string option * Ast.selector))

let _menhir_action_035 =
  fun left ->
    (
# 630 "packages/parser/lib/css_parser.mly"
                                               ( Selector left )
# 1690 "packages/parser/lib/css_parser.ml"
     : (Ast.complex_selector))

let _menhir_action_036 =
  fun s seq ->
    let left = 
# 625 "packages/parser/lib/css_parser.mly"
                        ( SimpleSelector s )
# 1698 "packages/parser/lib/css_parser.ml"
     in
    (
# 631 "packages/parser/lib/css_parser.mly"
                                                                             (
    Combinator {
      left = left;
      right = seq;
    }
  )
# 1708 "packages/parser/lib/css_parser.ml"
     : (Ast.complex_selector))

let _menhir_action_037 =
  fun s seq ->
    let left = 
# 626 "packages/parser/lib/css_parser.mly"
                          ( CompoundSelector s )
# 1716 "packages/parser/lib/css_parser.ml"
     in
    (
# 631 "packages/parser/lib/css_parser.mly"
                                                                             (
    Combinator {
      left = left;
      right = seq;
    }
  )
# 1726 "packages/parser/lib/css_parser.ml"
     : (Ast.complex_selector))

let _menhir_action_038 =
  fun ps sub ->
    (
# 579 "packages/parser/lib/css_parser.mly"
                                                            (
     {
      type_selector = None;
      subclass_selectors = sub;
      pseudo_selectors = ps;
    }
  )
# 1740 "packages/parser/lib/css_parser.ml"
     : (Ast.compound_selector))

let _menhir_action_039 =
  fun sub t ->
    (
# 587 "packages/parser/lib/css_parser.mly"
                                                             (
     {
      type_selector = Some t;
      subclass_selectors = sub;
      pseudo_selectors = [];
    }
  )
# 1754 "packages/parser/lib/css_parser.ml"
     : (Ast.compound_selector))

let _menhir_action_040 =
  fun sub ->
    (
# 595 "packages/parser/lib/css_parser.mly"
                                           (
     {
      type_selector = None;
      subclass_selectors = sub;
      pseudo_selectors = [];
    }
  )
# 1768 "packages/parser/lib/css_parser.ml"
     : (Ast.compound_selector))

let _menhir_action_041 =
  fun ps t ->
    (
# 603 "packages/parser/lib/css_parser.mly"
                                       (
     {
      type_selector = Some t;
      subclass_selectors = [];
      pseudo_selectors = ps;
    }
  )
# 1782 "packages/parser/lib/css_parser.ml"
     : (Ast.compound_selector))

let _menhir_action_042 =
  fun ps ->
    (
# 611 "packages/parser/lib/css_parser.mly"
                     (
     {
      type_selector = None;
      subclass_selectors = [];
      pseudo_selectors = ps;
    }
  )
# 1796 "packages/parser/lib/css_parser.ml"
     : (Ast.compound_selector))

let _menhir_action_043 =
  fun d ->
    (
# 389 "packages/parser/lib/css_parser.mly"
                                                                ( d )
# 1804 "packages/parser/lib/css_parser.ml"
     : (Ast.declaration))

let _menhir_action_044 =
  fun _endpos__2_ _startpos__1_ ->
    let _endpos = _endpos__2_ in
    let _startpos = _startpos__1_ in
    (
# 65 "packages/parser/lib/css_parser.mly"
            ( ([], make_loc _startpos _endpos) )
# 1814 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_045 =
  fun ds ->
    (
# 66 "packages/parser/lib/css_parser.mly"
                               ( ds )
# 1822 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_046 =
  fun _endpos__9_ _startpos_property_ important property value ->
    let _endpos = _endpos__9_ in
    let _startpos = _startpos_property_ in
    (
# 397 "packages/parser/lib/css_parser.mly"
                    (
    { name = property;
      value;
      important;
      loc = make_loc _startpos _endpos;
    }
  )
# 1838 "packages/parser/lib/css_parser.ml"
     : (Ast.declaration))

let _menhir_action_047 =
  fun xs ->
    (
# 379 "packages/parser/lib/css_parser.mly"
                                             ( xs )
# 1846 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_048 =
  fun xs ->
    (
# 380 "packages/parser/lib/css_parser.mly"
                                                                   ( xs )
# 1854 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_049 =
  fun x y ->
    let _1 = 
# 172 "<standard.mly>"
    ( (x, y) )
# 1862 "packages/parser/lib/css_parser.ml"
     in
    (
# 87 "packages/parser/lib/css_parser.mly"
                                                 ( [] )
# 1867 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_050 =
  fun eq ->
    (
# 106 "packages/parser/lib/css_parser.mly"
                            ( eq )
# 1875 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_051 =
  fun gt ->
    (
# 102 "packages/parser/lib/css_parser.mly"
                                            ( gt )
# 1883 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_052 =
  fun h ->
    (
# 515 "packages/parser/lib/css_parser.mly"
                      ( Id h )
# 1891 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_053 =
  fun v ->
    (
# 124 "packages/parser/lib/css_parser.mly"
                    ( Variable v)
# 1899 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_054 =
  fun rules ->
    (
# 69 "packages/parser/lib/css_parser.mly"
                                                     ( rules )
# 1907 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_055 =
  fun _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ declarations id ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 317 "packages/parser/lib/css_parser.mly"
                                                      (
    let prelude = [(SimpleSelector (Type id), make_loc _startpos_id_ _endpos_id_)] in
    Style_rule {
      prelude = (prelude, make_loc _startpos_id_ _endpos_id_);
      loc = make_loc _startpos _endpos;
      block = declarations;
    }
  )
# 1924 "packages/parser/lib/css_parser.ml"
     : (Ast.rule))

let _menhir_action_056 =
  fun _endpos__5_ _endpos_p_ _startpos__1_ _startpos_p_ declarations p ->
    let _endpos = _endpos__5_ in
    let _startpos = _startpos__1_ in
    (
# 327 "packages/parser/lib/css_parser.mly"
                                                      (
    let item = Percentage p in
    let prelude = [(SimpleSelector item, make_loc _startpos_p_ _endpos_p_)] in
    Style_rule {
      prelude = (prelude, make_loc _startpos_p_ _endpos_p_);
      loc = make_loc _startpos _endpos;
      block = declarations;
    }
  )
# 1942 "packages/parser/lib/css_parser.ml"
     : (Ast.rule))

let _menhir_action_057 =
  fun _endpos__3_ _endpos_xs_ _startpos_xs_ declarations xs ->
    let percentages = 
# 241 "<standard.mly>"
    ( xs )
# 1950 "packages/parser/lib/css_parser.ml"
     in
    let (_endpos_percentages_, _startpos_percentages_) = (_endpos_xs_, _startpos_xs_) in
    let _endpos = _endpos__3_ in
    let _startpos = _startpos_percentages_ in
    (
# 337 "packages/parser/lib/css_parser.mly"
                                                      (
    let prelude = percentages
      |> List.map (fun percent -> Percentage percent)
      |> List.map (fun p ->
        (SimpleSelector p, make_loc _startpos_percentages_ _endpos_percentages_)
      ) in
    Style_rule {
      prelude = (prelude, make_loc _startpos_percentages_ _endpos_percentages_);
      loc = make_loc _startpos _endpos;
      block = declarations;
    }
    (* TODO: Handle separated_list(COMMA, percentage) *)
  )
# 1970 "packages/parser/lib/css_parser.ml"
     : (Ast.rule))

let _menhir_action_058 =
  fun rules ->
    (
# 72 "packages/parser/lib/css_parser.mly"
                              ( rules )
# 1978 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_059 =
  fun rules ->
    (
# 73 "packages/parser/lib/css_parser.mly"
                                           ( rules )
# 1986 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_060 =
  fun lt ->
    (
# 104 "packages/parser/lib/css_parser.mly"
                                         ( lt )
# 1994 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_061 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 2002 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector list))

let _menhir_action_062 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 2010 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector list))

let _menhir_action_063 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 2018 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_064 =
  fun d xs ->
    let x = 
# 385 "packages/parser/lib/css_parser.mly"
                                          ( Declaration d )
# 2026 "packages/parser/lib/css_parser.ml"
     in
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 2031 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_065 =
  fun r xs ->
    let x = 
# 386 "packages/parser/lib/css_parser.mly"
                         ( At_rule r )
# 2039 "packages/parser/lib/css_parser.ml"
     in
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 2044 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_066 =
  fun s xs ->
    let x = 
# 387 "packages/parser/lib/css_parser.mly"
                            ( Style_rule s )
# 2052 "packages/parser/lib/css_parser.ml"
     in
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 2057 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_067 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2067 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_068 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2077 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_069 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2087 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_070 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2097 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_071 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2107 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_072 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2117 "packages/parser/lib/css_parser.ml"
     : (string Ast.with_loc))

let _menhir_action_073 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2127 "packages/parser/lib/css_parser.ml"
     : (bool Ast.with_loc))

let _menhir_action_074 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2137 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_075 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2147 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_076 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2157 "packages/parser/lib/css_parser.ml"
     : (Ast.rule_list))

let _menhir_action_077 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2167 "packages/parser/lib/css_parser.ml"
     : (Ast.stylesheet))

let _menhir_action_078 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2177 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value Ast.with_loc))

let _menhir_action_079 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2187 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value Ast.with_loc))

let _menhir_action_080 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2197 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload Ast.with_loc))

let _menhir_action_081 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2207 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value Ast.with_loc))

let _menhir_action_082 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2217 "packages/parser/lib/css_parser.ml"
     : (Ast.selector Ast.with_loc))

let _menhir_action_083 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2227 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list Ast.with_loc))

let _menhir_action_084 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2237 "packages/parser/lib/css_parser.ml"
     : (Ast.selector Ast.with_loc))

let _menhir_action_085 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2247 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list Ast.with_loc))

let _menhir_action_086 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2257 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value Ast.with_loc))

let _menhir_action_087 =
  fun _endpos_x_ _startpos_x_ x ->
    (
# 76 "packages/parser/lib/css_parser.mly"
              (
  (x, make_loc _startpos_x_ _endpos_x_)
)
# 2267 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list Ast.with_loc))

let _menhir_action_088 =
  fun () ->
    (
# 145 "<standard.mly>"
    ( [] )
# 2275 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_089 =
  fun x ->
    (
# 148 "<standard.mly>"
    ( x )
# 2283 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_090 =
  fun xs ->
    (
# 186 "packages/parser/lib/css_parser.mly"
                                             ( xs )
# 2291 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_091 =
  fun xs ->
    (
# 209 "packages/parser/lib/css_parser.mly"
                        ( xs )
# 2299 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_092 =
  fun xs ->
    (
# 210 "packages/parser/lib/css_parser.mly"
                       ( xs )
# 2307 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_093 =
  fun () ->
    (
# 191 "packages/parser/lib/css_parser.mly"
    ( [] )
# 2315 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_094 =
  fun and_rule rest ->
    (
# 194 "packages/parser/lib/css_parser.mly"
    ( and_rule :: rest )
# 2323 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_095 =
  fun mn ->
    (
# 214 "packages/parser/lib/css_parser.mly"
                   ( mn )
# 2331 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_096 =
  fun xs ->
    (
# 215 "packages/parser/lib/css_parser.mly"
                                               ( xs )
# 2339 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_097 =
  fun mn ->
    (
# 219 "packages/parser/lib/css_parser.mly"
                   ( mn )
# 2347 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_098 =
  fun xs ->
    (
# 220 "packages/parser/lib/css_parser.mly"
                                            ( xs )
# 2355 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_099 =
  fun mfp ->
    (
# 171 "packages/parser/lib/css_parser.mly"
                   ( mfp )
# 2363 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_100 =
  fun mfb ->
    (
# 172 "packages/parser/lib/css_parser.mly"
                     ( mfb )
# 2371 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_101 =
  fun mfr ->
    (
# 173 "packages/parser/lib/css_parser.mly"
                   ( mfr )
# 2379 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_102 =
  fun mc ->
    (
# 179 "packages/parser/lib/css_parser.mly"
                                                ( mc )
# 2387 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_103 =
  fun mf ->
    (
# 180 "packages/parser/lib/css_parser.mly"
                                                      ( Ident mf )
# 2395 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_104 =
  fun i ->
    (
# 181 "packages/parser/lib/css_parser.mly"
                      ( i )
# 2403 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_105 =
  fun mn ->
    (
# 183 "packages/parser/lib/css_parser.mly"
                                                     ( Ident mn )
# 2411 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_106 =
  fun xs ->
    (
# 197 "packages/parser/lib/css_parser.mly"
                                           ( xs )
# 2419 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_107 =
  fun () ->
    (
# 202 "packages/parser/lib/css_parser.mly"
    ( [] )
# 2427 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_108 =
  fun or_rule rest ->
    (
# 205 "packages/parser/lib/css_parser.mly"
    ( or_rule :: rest )
# 2435 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_109 =
  fun mc ->
    (
# 232 "packages/parser/lib/css_parser.mly"
                                        ( mc )
# 2443 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_110 =
  fun xs ->
    (
# 234 "packages/parser/lib/css_parser.mly"
                                                    ( Ident xs )
# 2451 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_111 =
  fun xs ->
    (
# 235 "packages/parser/lib/css_parser.mly"
                                                                              ( Ident xs )
# 2459 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_112 =
  fun v ->
    (
# 238 "packages/parser/lib/css_parser.mly"
                      ( Variable v )
# 2467 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_113 =
  fun mq ->
    (
# 239 "packages/parser/lib/css_parser.mly"
                                         ( Paren_block mq )
# 2475 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_114 =
  fun i ->
    (
# 162 "packages/parser/lib/css_parser.mly"
                  ( i )
# 2483 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_115 =
  fun all_mt ->
    (
# 163 "packages/parser/lib/css_parser.mly"
                                ( all_mt )
# 2491 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_116 =
  fun mt ->
    (
# 164 "packages/parser/lib/css_parser.mly"
                                        ( mt )
# 2499 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_117 =
  fun mt ->
    (
# 165 "packages/parser/lib/css_parser.mly"
                                                                           ( mt )
# 2507 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_118 =
  fun mt ->
    (
# 166 "packages/parser/lib/css_parser.mly"
                                                                                 ( mt )
# 2515 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_119 =
  fun mflt ->
    (
# 141 "packages/parser/lib/css_parser.mly"
                 ( mflt )
# 2523 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_120 =
  fun mfgt ->
    (
# 142 "packages/parser/lib/css_parser.mly"
                 ( mfgt )
# 2531 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_121 =
  fun mfeq ->
    (
# 143 "packages/parser/lib/css_parser.mly"
                      ( mfeq )
# 2539 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_122 =
  fun mglt ->
    (
# 137 "packages/parser/lib/css_parser.mly"
                                       ( mglt )
# 2547 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_123 =
  fun mflt ->
    (
# 134 "packages/parser/lib/css_parser.mly"
                                    ( mflt )
# 2555 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_124 =
  fun mf ->
    (
# 131 "packages/parser/lib/css_parser.mly"
                                            ( mf )
# 2563 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_125 =
  fun xs ->
    (
# 151 "packages/parser/lib/css_parser.mly"
                                            ( xs )
# 2571 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_126 =
  fun xs ->
    (
# 152 "packages/parser/lib/css_parser.mly"
                                            ( xs )
# 2579 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_127 =
  fun xs ->
    (
# 153 "packages/parser/lib/css_parser.mly"
                                                         ( xs )
# 2587 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_128 =
  fun xs ->
    (
# 154 "packages/parser/lib/css_parser.mly"
                                                         ( xs )
# 2595 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_129 =
  fun v ->
    (
# 127 "packages/parser/lib/css_parser.mly"
                      ( v )
# 2603 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_130 =
  fun v ->
    (
# 128 "packages/parser/lib/css_parser.mly"
              ( v )
# 2611 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_131 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2619 "packages/parser/lib/css_parser.ml"
     : ((string option * Ast.selector) list))

let _menhir_action_132 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2627 "packages/parser/lib/css_parser.ml"
     : ((string option * Ast.selector) list))

let _menhir_action_133 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2635 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_134 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2643 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_135 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2651 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_136 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2659 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_137 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2667 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_138 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2675 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_139 =
  fun d ->
    let x = 
# 385 "packages/parser/lib/css_parser.mly"
                                          ( Declaration d )
# 2683 "packages/parser/lib/css_parser.ml"
     in
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2688 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_140 =
  fun r ->
    let x = 
# 386 "packages/parser/lib/css_parser.mly"
                         ( At_rule r )
# 2696 "packages/parser/lib/css_parser.ml"
     in
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2701 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_141 =
  fun s ->
    let x = 
# 387 "packages/parser/lib/css_parser.mly"
                            ( Style_rule s )
# 2709 "packages/parser/lib/css_parser.ml"
     in
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2714 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_142 =
  fun d xs ->
    let x = 
# 385 "packages/parser/lib/css_parser.mly"
                                          ( Declaration d )
# 2722 "packages/parser/lib/css_parser.ml"
     in
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2727 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_143 =
  fun r xs ->
    let x = 
# 386 "packages/parser/lib/css_parser.mly"
                         ( At_rule r )
# 2735 "packages/parser/lib/css_parser.ml"
     in
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2740 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_144 =
  fun s xs ->
    let x = 
# 387 "packages/parser/lib/css_parser.mly"
                            ( Style_rule s )
# 2748 "packages/parser/lib/css_parser.ml"
     in
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2753 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_145 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 2761 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector list))

let _menhir_action_146 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 2769 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector list))

let _menhir_action_147 =
  fun n ->
    (
# 114 "packages/parser/lib/css_parser.mly"
                                       ( n )
# 2777 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_148 =
  fun n ->
    (
# 224 "packages/parser/lib/css_parser.mly"
                     ( n )
# 2785 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_149 =
  fun o ->
    (
# 225 "packages/parser/lib/css_parser.mly"
                      ( o )
# 2793 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_150 =
  fun a ->
    (
# 414 "packages/parser/lib/css_parser.mly"
               ( Nth (A (int_of_string a)) )
# 2801 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_151 =
  fun a ->
    (
# 416 "packages/parser/lib/css_parser.mly"
                  ( Nth (AN (int_of_string (fst a))) )
# 2809 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_152 =
  fun a b combinator ->
    (
# 418 "packages/parser/lib/css_parser.mly"
                                                         (
    let b = int_of_string b in
    Nth (ANB (((int_of_string (fst a)), combinator, b)))
  )
# 2820 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_153 =
  fun a b ->
    (
# 424 "packages/parser/lib/css_parser.mly"
                                 (
    let b = Int.abs (int_of_string (b)) in
    Nth (ANB (((int_of_string (fst a)), "-", b)))
  )
# 2831 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_154 =
  fun n ->
    (
# 428 "packages/parser/lib/css_parser.mly"
                  (
    match n with
      | "even" -> Nth (Even)
      | "odd" -> Nth (Odd)
      | "n" -> Nth (AN 1)
      | _ -> (
        let first_char = String.get n 0 in
        let a = if first_char = '-' then -1 else 1 in
        Nth (AN a)
      )
  )
# 2849 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_155 =
  fun b combinator n ->
    (
# 442 "packages/parser/lib/css_parser.mly"
                                                     (
    let first_char = String.get n 0 in
    let a = if first_char = '-' then -1 else 1 in
    Nth (ANB ((a, combinator, int_of_string b)))
  )
# 2861 "packages/parser/lib/css_parser.ml"
     : (Ast.nth_payload))

let _menhir_action_156 =
  fun o ->
    (
# 112 "packages/parser/lib/css_parser.mly"
                                        ( o )
# 2869 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_157 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2877 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_158 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2885 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_159 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2893 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_160 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2901 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_161 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2909 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_162 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2917 "packages/parser/lib/css_parser.ml"
     : (unit option))

let _menhir_action_163 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2925 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value option))

let _menhir_action_164 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2933 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value option))

let _menhir_action_165 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2941 "packages/parser/lib/css_parser.ml"
     : (string option))

let _menhir_action_166 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2949 "packages/parser/lib/css_parser.ml"
     : (string option))

let _menhir_action_167 =
  fun () ->
    (
# 111 "<standard.mly>"
    ( None )
# 2957 "packages/parser/lib/css_parser.ml"
     : (string option))

let _menhir_action_168 =
  fun x ->
    (
# 114 "<standard.mly>"
    ( Some x )
# 2965 "packages/parser/lib/css_parser.ml"
     : (string option))

let _menhir_action_169 =
  fun o ->
    (
# 110 "packages/parser/lib/css_parser.mly"
                                      ( o )
# 2973 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_170 =
  fun x ->
    let xs = 
# 205 "<standard.mly>"
    ( x )
# 2981 "packages/parser/lib/css_parser.ml"
     in
    (
# 97 "packages/parser/lib/css_parser.mly"
                                                            ( xs )
# 2986 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_171 =
  fun n ->
    (
# 311 "packages/parser/lib/css_parser.mly"
                               ( n )
# 2994 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_172 =
  fun xs ->
    (
# 241 "packages/parser/lib/css_parser.mly"
                    ( xs )
# 3002 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_173 =
  fun pmt ->
    (
# 118 "packages/parser/lib/css_parser.mly"
                                         ( pmt )
# 3010 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_174 =
  fun i ->
    (
# 451 "packages/parser/lib/css_parser.mly"
                    ( (Pseudoclass(PseudoIdent i)) )
# 3018 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector))

let _menhir_action_175 =
  fun f xs ->
    (
# 452 "packages/parser/lib/css_parser.mly"
                                                                                 (
    (Pseudoclass(Function({ name = f; payload = xs })))
  )
# 3028 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector))

let _menhir_action_176 =
  fun f xs ->
    (
# 455 "packages/parser/lib/css_parser.mly"
                                                                        (
    (Pseudoclass(Function({ name = f; payload = xs })))
  )
# 3038 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector))

let _menhir_action_177 =
  fun f xs ->
    (
# 458 "packages/parser/lib/css_parser.mly"
                                                                          (
    (Pseudoclass(NthFunction({ name = f; payload = xs })))
  )
# 3048 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector))

let _menhir_action_178 =
  fun pse ->
    (
# 561 "packages/parser/lib/css_parser.mly"
                            ( Pseudoelement pse )
# 3056 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector))

let _menhir_action_179 =
  fun class_list element ->
    (
# 566 "packages/parser/lib/css_parser.mly"
                                                                               (
    element :: class_list
  )
# 3066 "packages/parser/lib/css_parser.ml"
     : (Ast.pseudo_selector list))

let _menhir_action_180 =
  fun xs ->
    (
# 639 "packages/parser/lib/css_parser.mly"
                                         ( RelativeSelector { combinator = None; complex_selector = xs} )
# 3074 "packages/parser/lib/css_parser.ml"
     : (Ast.selector))

let _menhir_action_181 =
  fun c xs ->
    (
# 640 "packages/parser/lib/css_parser.mly"
                                                 ( RelativeSelector { combinator = Some c; complex_selector = xs } )
# 3082 "packages/parser/lib/css_parser.ml"
     : (Ast.selector))

let _menhir_action_182 =
  fun selector ->
    (
# 356 "packages/parser/lib/css_parser.mly"
                                          ( [selector] )
# 3090 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list))

let _menhir_action_183 =
  fun selector seq ->
    (
# 357 "packages/parser/lib/css_parser.mly"
                                                                                     ( selector :: seq )
# 3098 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list))

let _menhir_action_184 =
  fun smt ->
    (
# 116 "packages/parser/lib/css_parser.mly"
                                           ( smt )
# 3106 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_185 =
  fun mt ->
    (
# 157 "packages/parser/lib/css_parser.mly"
                           ( mt )
# 3114 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_186 =
  fun mt ->
    (
# 158 "packages/parser/lib/css_parser.mly"
                          ( mt )
# 3122 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_187 =
  fun xs ->
    (
# 541 "packages/parser/lib/css_parser.mly"
                                         ( ComplexSelector xs )
# 3130 "packages/parser/lib/css_parser.ml"
     : (Ast.selector))

let _menhir_action_188 =
  fun selector ->
    (
# 352 "packages/parser/lib/css_parser.mly"
                                 ( [selector] )
# 3138 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list))

let _menhir_action_189 =
  fun selector seq ->
    (
# 353 "packages/parser/lib/css_parser.mly"
                                                                   ( selector :: seq )
# 3146 "packages/parser/lib/css_parser.ml"
     : (Ast.selector_list))

let _menhir_action_190 =
  fun x ->
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 3154 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_191 =
  fun x xs ->
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 3162 "packages/parser/lib/css_parser.ml"
     : (string list))

let _menhir_action_192 =
  fun d ->
    let x = 
# 385 "packages/parser/lib/css_parser.mly"
                                          ( Declaration d )
# 3170 "packages/parser/lib/css_parser.ml"
     in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 3175 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_193 =
  fun r ->
    let x = 
# 386 "packages/parser/lib/css_parser.mly"
                         ( At_rule r )
# 3183 "packages/parser/lib/css_parser.ml"
     in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 3188 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_194 =
  fun s ->
    let x = 
# 387 "packages/parser/lib/css_parser.mly"
                            ( Style_rule s )
# 3196 "packages/parser/lib/css_parser.ml"
     in
    (
# 250 "<standard.mly>"
    ( [ x ] )
# 3201 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_195 =
  fun d xs ->
    let x = 
# 385 "packages/parser/lib/css_parser.mly"
                                          ( Declaration d )
# 3209 "packages/parser/lib/css_parser.ml"
     in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 3214 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_196 =
  fun r xs ->
    let x = 
# 386 "packages/parser/lib/css_parser.mly"
                         ( At_rule r )
# 3222 "packages/parser/lib/css_parser.ml"
     in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 3227 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_197 =
  fun s xs ->
    let x = 
# 387 "packages/parser/lib/css_parser.mly"
                            ( Style_rule s )
# 3235 "packages/parser/lib/css_parser.ml"
     in
    (
# 253 "<standard.mly>"
    ( x :: xs )
# 3240 "packages/parser/lib/css_parser.ml"
     : (Ast.rule list))

let _menhir_action_198 =
  fun t ->
    (
# 556 "packages/parser/lib/css_parser.mly"
                      ( t )
# 3248 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_199 =
  fun x ->
    let x = 
# 205 "<standard.mly>"
    ( x )
# 3256 "packages/parser/lib/css_parser.ml"
     in
    (
# 81 "packages/parser/lib/css_parser.mly"
                                        ( x )
# 3261 "packages/parser/lib/css_parser.ml"
     : (Ast.at_rule))

let _menhir_action_200 =
  fun x ->
    let x = 
# 205 "<standard.mly>"
    ( x )
# 3269 "packages/parser/lib/css_parser.ml"
     in
    (
# 81 "packages/parser/lib/css_parser.mly"
                                        ( x )
# 3274 "packages/parser/lib/css_parser.ml"
     : (Ast.declaration))

let _menhir_action_201 =
  fun x ->
    let x = 
# 205 "<standard.mly>"
    ( x )
# 3282 "packages/parser/lib/css_parser.ml"
     in
    (
# 81 "packages/parser/lib/css_parser.mly"
                                        ( x )
# 3287 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_202 =
  fun x ->
    let x = 
# 205 "<standard.mly>"
    ( x )
# 3295 "packages/parser/lib/css_parser.ml"
     in
    (
# 81 "packages/parser/lib/css_parser.mly"
                                        ( x )
# 3300 "packages/parser/lib/css_parser.ml"
     : (Ast.style_rule))

let _menhir_action_203 =
  fun x ->
    let x = 
# 205 "<standard.mly>"
    ( x )
# 3308 "packages/parser/lib/css_parser.ml"
     in
    (
# 81 "packages/parser/lib/css_parser.mly"
                                        ( x )
# 3313 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_204 =
  fun x ->
    (
# 83 "packages/parser/lib/css_parser.mly"
                             ( x )
# 3321 "packages/parser/lib/css_parser.ml"
     : (Ast.declaration))

let _menhir_action_205 =
  fun x ->
    (
# 82 "packages/parser/lib/css_parser.mly"
                              ( x )
# 3329 "packages/parser/lib/css_parser.ml"
     : (Ast.complex_selector))

let _menhir_action_206 =
  fun s ->
    let x = 
# 625 "packages/parser/lib/css_parser.mly"
                        ( SimpleSelector s )
# 3337 "packages/parser/lib/css_parser.ml"
     in
    (
# 82 "packages/parser/lib/css_parser.mly"
                              ( x )
# 3342 "packages/parser/lib/css_parser.ml"
     : (Ast.selector))

let _menhir_action_207 =
  fun s ->
    let x = 
# 626 "packages/parser/lib/css_parser.mly"
                          ( CompoundSelector s )
# 3350 "packages/parser/lib/css_parser.ml"
     in
    (
# 82 "packages/parser/lib/css_parser.mly"
                              ( x )
# 3355 "packages/parser/lib/css_parser.ml"
     : (Ast.selector))

let _menhir_action_208 =
  fun _endpos_block_ _startpos_prelude_ block prelude ->
    let _endpos = _endpos_block_ in
    let _startpos = _startpos_prelude_ in
    (
# 362 "packages/parser/lib/css_parser.mly"
                                   (
    { prelude;
      block;
      loc = make_loc _startpos _endpos;
    }
  )
# 3370 "packages/parser/lib/css_parser.ml"
     : (Ast.style_rule))

let _menhir_action_209 =
  fun _endpos_declarations_ _startpos_prelude_ declarations prelude ->
    let _endpos = _endpos_declarations_ in
    let _startpos = _startpos_prelude_ in
    (
# 369 "packages/parser/lib/css_parser.mly"
                                                  (
    { prelude;
      block = declarations;
      loc = make_loc _startpos _endpos;
    }
  )
# 3385 "packages/parser/lib/css_parser.ml"
     : (Ast.style_rule))

let _menhir_action_210 =
  fun s ->
    (
# 61 "packages/parser/lib/css_parser.mly"
                                            ( s )
# 3393 "packages/parser/lib/css_parser.ml"
     : (Ast.stylesheet))

let _menhir_action_211 =
  fun rs ->
    (
# 62 "packages/parser/lib/css_parser.mly"
                                             ( rs )
# 3401 "packages/parser/lib/css_parser.ml"
     : (Ast.stylesheet))

let _menhir_action_212 =
  fun id ->
    (
# 525 "packages/parser/lib/css_parser.mly"
                     ( id )
# 3409 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_213 =
  fun c ->
    (
# 526 "packages/parser/lib/css_parser.mly"
                       ( c )
# 3417 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_214 =
  fun a ->
    (
# 527 "packages/parser/lib/css_parser.mly"
                           ( a )
# 3425 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_215 =
  fun pcs ->
    (
# 528 "packages/parser/lib/css_parser.mly"
                                ( Pseudo_class pcs )
# 3433 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_216 =
  fun v ->
    (
# 529 "packages/parser/lib/css_parser.mly"
                          ( ClassVariable v )
# 3441 "packages/parser/lib/css_parser.ml"
     : (Ast.subclass_selector))

let _menhir_action_217 =
  fun () ->
    (
# 544 "packages/parser/lib/css_parser.mly"
               ( Ampersand )
# 3449 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_218 =
  fun () ->
    (
# 545 "packages/parser/lib/css_parser.mly"
              ( Universal )
# 3457 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_219 =
  fun v ->
    (
# 546 "packages/parser/lib/css_parser.mly"
                      ( Variable v )
# 3465 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_220 =
  fun type_ ->
    (
# 550 "packages/parser/lib/css_parser.mly"
                   ( Type type_ )
# 3473 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_221 =
  fun type_ ->
    (
# 551 "packages/parser/lib/css_parser.mly"
                 ( Type type_ )
# 3481 "packages/parser/lib/css_parser.ml"
     : (Ast.simple_selector))

let _menhir_action_222 =
  fun b ->
    (
# 643 "packages/parser/lib/css_parser.mly"
                            ( Paren_block b )
# 3489 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_223 =
  fun b ->
    (
# 644 "packages/parser/lib/css_parser.mly"
                              ( Bracket_block b )
# 3497 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_224 =
  fun n ->
    (
# 645 "packages/parser/lib/css_parser.mly"
                   ( Percentage n )
# 3505 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_225 =
  fun i ->
    (
# 646 "packages/parser/lib/css_parser.mly"
              ( Ident i )
# 3513 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_226 =
  fun i ->
    (
# 647 "packages/parser/lib/css_parser.mly"
            ( Ident i )
# 3521 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_227 =
  fun s ->
    (
# 648 "packages/parser/lib/css_parser.mly"
               ( String s )
# 3529 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_228 =
  fun c ->
    (
# 649 "packages/parser/lib/css_parser.mly"
                   ( Combinator c)
# 3537 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_229 =
  fun o ->
    (
# 650 "packages/parser/lib/css_parser.mly"
                 ( Operator o )
# 3545 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_230 =
  fun d ->
    (
# 651 "packages/parser/lib/css_parser.mly"
              ( Delim d )
# 3553 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_231 =
  fun () ->
    (
# 652 "packages/parser/lib/css_parser.mly"
        ( Delim "." )
# 3561 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_232 =
  fun () ->
    (
# 653 "packages/parser/lib/css_parser.mly"
             ( Delim "*" )
# 3569 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_233 =
  fun () ->
    (
# 654 "packages/parser/lib/css_parser.mly"
          ( Delim ":" )
# 3577 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_234 =
  fun h ->
    (
# 655 "packages/parser/lib/css_parser.mly"
             ( Hash h )
# 3585 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_235 =
  fun () ->
    (
# 656 "packages/parser/lib/css_parser.mly"
                 ( Delim "::" )
# 3593 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_236 =
  fun () ->
    (
# 657 "packages/parser/lib/css_parser.mly"
          ( Delim "," )
# 3601 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_237 =
  fun n ->
    (
# 658 "packages/parser/lib/css_parser.mly"
               ( Number n )
# 3609 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_238 =
  fun r ->
    (
# 659 "packages/parser/lib/css_parser.mly"
                      ( Unicode_range r )
# 3617 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_239 =
  fun d ->
    (
# 660 "packages/parser/lib/css_parser.mly"
                        ( Float_dimension d )
# 3625 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_240 =
  fun d ->
    (
# 661 "packages/parser/lib/css_parser.mly"
                  ( Dimension d )
# 3633 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_241 =
  fun v ->
    (
# 662 "packages/parser/lib/css_parser.mly"
                      ( Variable v )
# 3641 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_242 =
  fun f v ->
    (
# 663 "packages/parser/lib/css_parser.mly"
                                                   ( Function (f, v) )
# 3649 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_243 =
  fun u ->
    (
# 664 "packages/parser/lib/css_parser.mly"
            ( Uri u )
# 3657 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_244 =
  fun mq_operator ->
    (
# 665 "packages/parser/lib/css_parser.mly"
                                       ( Operator mq_operator )
# 3665 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_245 =
  fun all ->
    (
# 666 "packages/parser/lib/css_parser.mly"
                         ( Operator all )
# 3673 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_246 =
  fun screen ->
    (
# 667 "packages/parser/lib/css_parser.mly"
                               ( Ident screen)
# 3681 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value))

let _menhir_action_247 =
  fun xs ->
    (
# 376 "packages/parser/lib/css_parser.mly"
                                                ( xs )
# 3689 "packages/parser/lib/css_parser.ml"
     : (Ast.component_value_list))

let _menhir_action_248 =
  fun i ->
    (
# 470 "packages/parser/lib/css_parser.mly"
              ( i )
# 3697 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_action_249 =
  fun t ->
    (
# 471 "packages/parser/lib/css_parser.mly"
            ( t )
# 3705 "packages/parser/lib/css_parser.ml"
     : (string))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | ALL_MEDIA_TYPE _ ->
        "ALL_MEDIA_TYPE"
    | AMPERSAND ->
        "AMPERSAND"
    | ASTERISK ->
        "ASTERISK"
    | AT_KEYFRAMES _ ->
        "AT_KEYFRAMES"
    | AT_MEDIA _ ->
        "AT_MEDIA"
    | AT_RULE _ ->
        "AT_RULE"
    | AT_RULE_STATEMENT _ ->
        "AT_RULE_STATEMENT"
    | BAD_IDENT ->
        "BAD_IDENT"
    | BAD_URL ->
        "BAD_URL"
    | COLON ->
        "COLON"
    | COMBINATOR _ ->
        "COMBINATOR"
    | COMMA ->
        "COMMA"
    | DELIM _ ->
        "DELIM"
    | DIMENSION _ ->
        "DIMENSION"
    | DOT ->
        "DOT"
    | DOUBLE_COLON ->
        "DOUBLE_COLON"
    | EOF ->
        "EOF"
    | EQUAL_SIGN _ ->
        "EQUAL_SIGN"
    | FLOAT_DIMENSION _ ->
        "FLOAT_DIMENSION"
    | FUNCTION _ ->
        "FUNCTION"
    | HASH _ ->
        "HASH"
    | IDENT _ ->
        "IDENT"
    | IMPORTANT ->
        "IMPORTANT"
    | INTERPOLATION _ ->
        "INTERPOLATION"
    | LEFT_BRACE ->
        "LEFT_BRACE"
    | LEFT_BRACKET ->
        "LEFT_BRACKET"
    | LEFT_PAREN ->
        "LEFT_PAREN"
    | MEDIA_FEATURE_COMPARISON _ ->
        "MEDIA_FEATURE_COMPARISON"
    | MEDIA_QUERY_OPERATOR _ ->
        "MEDIA_QUERY_OPERATOR"
    | NTH_FUNCTION _ ->
        "NTH_FUNCTION"
    | NUMBER _ ->
        "NUMBER"
    | OPERATOR _ ->
        "OPERATOR"
    | PERCENT ->
        "PERCENT"
    | PRINT_MEDIA_TYPE _ ->
        "PRINT_MEDIA_TYPE"
    | RIGHT_BRACE ->
        "RIGHT_BRACE"
    | RIGHT_BRACKET ->
        "RIGHT_BRACKET"
    | RIGHT_PAREN ->
        "RIGHT_PAREN"
    | SCREEN_MEDIA_TYPE _ ->
        "SCREEN_MEDIA_TYPE"
    | SEMI_COLON ->
        "SEMI_COLON"
    | STRING _ ->
        "STRING"
    | TAG _ ->
        "TAG"
    | UNICODE_RANGE _ ->
        "UNICODE_RANGE"
    | URL _ ->
        "URL"
    | WS ->
        "WS"

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_440 : 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_210 s in
          MenhirBox_stylesheet _v
      | _ ->
          _eRR ()
  
  let _menhir_goto_keyframes : type  ttv_stack. ttv_stack -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _v ->
      MenhirBox_keyframes _v
  
  let _menhir_run_432 : type  ttv_stack. ((ttv_stack, _menhir_box_keyframes) _menhir_cell1_LEFT_BRACE, _menhir_box_keyframes) _menhir_cell1_loc_keyframe_ _menhir_cell0_RIGHT_BRACE -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _tok ->
      let MenhirCell0_RIGHT_BRACE (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_loc_keyframe_ (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_LEFT_BRACE (_menhir_stack, _, _) = _menhir_stack in
      let _v = _menhir_action_022 x in
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let rules = _v in
          let _v = _menhir_action_059 rules in
          _menhir_goto_keyframes _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_goto_declaration_list : type  ttv_stack. ttv_stack -> _ -> _menhir_box_declaration_list =
    fun _menhir_stack _v ->
      MenhirBox_declaration_list _v
  
  let _menhir_run_425 : 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_045 ds in
          _menhir_goto_declaration_list _menhir_stack _v
      | _ ->
          _eRR ()
  
  let _menhir_run_003 : type  ttv_stack. (ttv_stack, _menhir_box_declaration) _menhir_cell1_skip_ws_left_declaration_without_eof_ -> _ -> _menhir_box_declaration =
    fun _menhir_stack _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let MenhirCell1_skip_ws_left_declaration_without_eof_ (_menhir_stack, _, d) = _menhir_stack in
          let _v = _menhir_action_043 d in
          MenhirBox_declaration _v
      | _ ->
          _eRR ()
  
  let _menhir_run_434 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _v _tok ->
      match (_tok : MenhirBasics.token) with
      | EOF ->
          let rules = _v in
          let _v = _menhir_action_058 rules in
          _menhir_goto_keyframes _menhir_stack _v
      | _ ->
          _eRR ()
  
  let rec _menhir_run_001 : 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_x_, _startpos_x_, x) = (_endpos, _startpos, ()) in
      let _v = _menhir_action_162 x in
      _menhir_goto_option_WS_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_option_WS_ : 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
      | MenhirState421 ->
          _menhir_run_422 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState419 ->
          _menhir_run_420 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState410 ->
          _menhir_run_411 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState406 ->
          _menhir_run_407 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState404 ->
          _menhir_run_405 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState402 ->
          _menhir_run_403 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState399 ->
          _menhir_run_400 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState428 ->
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState429 ->
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState412 ->
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState389 ->
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState395 ->
          _menhir_run_396 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState391 ->
          _menhir_run_393 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState387 ->
          _menhir_run_388 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState385 ->
          _menhir_run_386 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState381 ->
          _menhir_run_382 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState379 ->
          _menhir_run_380 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState377 ->
          _menhir_run_378 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState375 ->
          _menhir_run_376 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState373 ->
          _menhir_run_374 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState365 ->
          _menhir_run_366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState363 ->
          _menhir_run_364 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState361 ->
          _menhir_run_362 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState358 ->
          _menhir_run_359 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState355 ->
          _menhir_run_356 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState339 ->
          _menhir_run_340 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState336 ->
          _menhir_run_337 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState333 ->
          _menhir_run_334 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState306 ->
          _menhir_run_307 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState303 ->
          _menhir_run_304 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState280 ->
          _menhir_run_302 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState293 ->
          _menhir_run_294 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState289 ->
          _menhir_run_290 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState383 ->
          _menhir_run_286 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState249 ->
          _menhir_run_286 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState285 ->
          _menhir_run_286 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState283 ->
          _menhir_run_284 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState276 ->
          _menhir_run_277 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState258 ->
          _menhir_run_275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState251 ->
          _menhir_run_253 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState248 ->
          _menhir_run_249 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState246 ->
          _menhir_run_247 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState232 ->
          _menhir_run_233 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState230 ->
          _menhir_run_231 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState227 ->
          _menhir_run_228 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState223 ->
          _menhir_run_224 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState401 ->
          _menhir_run_203 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState201 ->
          _menhir_run_203 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState199 ->
          _menhir_run_200 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState197 ->
          _menhir_run_198 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState191 ->
          _menhir_run_192 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState189 ->
          _menhir_run_190 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState187 ->
          _menhir_run_188 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState184 ->
          _menhir_run_185 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState182 ->
          _menhir_run_183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState178 ->
          _menhir_run_179 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState175 ->
          _menhir_run_176 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState173 ->
          _menhir_run_174 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState170 ->
          _menhir_run_171 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState168 ->
          _menhir_run_169 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState160 ->
          _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState158 ->
          _menhir_run_159 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState156 ->
          _menhir_run_157 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState152 ->
          _menhir_run_153 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState148 ->
          _menhir_run_149 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState140 ->
          _menhir_run_141 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState110 ->
          _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState106 ->
          _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState091 ->
          _menhir_run_092 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState088 ->
          _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState086 ->
          _menhir_run_087 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState081 ->
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState077 ->
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState439 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState065 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState067 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState068 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState071 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState234 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState238 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState239 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState240 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState211 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState204 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState205 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState206 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState207 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState064 ->
          _menhir_run_065 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState057 ->
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState054 ->
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState046 ->
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState050 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState029 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState027 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState023 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState010 ->
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState009 ->
          _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState007 ->
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState000 ->
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState002 ->
          _menhir_run_003 _menhir_stack _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_422 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_at_rule -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_at_rule (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _v = _menhir_action_199 x in
      _menhir_goto_skip_ws_at_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_skip_ws_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
      | MenhirState439 ->
          _menhir_run_240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState234 ->
          _menhir_run_240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState238 ->
          _menhir_run_240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState240 ->
          _menhir_run_240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState239 ->
          _menhir_run_240 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState065 ->
          _menhir_run_211 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_211 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState067 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState211 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState204 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState205 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState207 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState206 ->
          _menhir_run_207 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState068 ->
          _menhir_run_072 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_072 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState071 ->
          _menhir_run_072 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_240 : 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_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState240
      | EOF | RIGHT_BRACE ->
          let _v_0 = _menhir_action_063 () in
          _menhir_run_241 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_1 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState240 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_241 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_at_rule_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, r, _startpos_r_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_065 r xs in
      _menhir_goto_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_r_ _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
      | MenhirState439 ->
          _menhir_run_245 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState234 ->
          _menhir_run_245 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState238 ->
          _menhir_run_243 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState239 ->
          _menhir_run_242 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState240 ->
          _menhir_run_241 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_245 : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_077 _endpos_x_ _startpos_x_ x in
      let rs = _v in
      let _v = _menhir_action_211 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
      | MenhirState439 ->
          _menhir_run_440 _menhir_stack _v _tok
      | MenhirState234 ->
          _menhir_run_235 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_235 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_LEFT_BRACE as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_stylesheet_without_eof (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_RIGHT_BRACE (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEMI_COLON ->
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState236
          | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | TAG _ | WS ->
              let _ = _menhir_action_159 () in
              _menhir_run_237 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_059 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_endpos_x_, x) = (_endpos, ()) in
      let _ = _menhir_action_160 x in
      _menhir_goto_option_SEMI_COLON_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _menhir_s _tok
  
  and _menhir_goto_option_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 _menhir_s _tok ->
      match _menhir_s with
      | MenhirState431 ->
          _menhir_run_432 _menhir_stack _tok
      | MenhirState415 ->
          _menhir_run_416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState236 ->
          _menhir_run_237 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState228 ->
          _menhir_run_229 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState217 ->
          _menhir_run_218 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState214 ->
          _menhir_run_215 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState212 ->
          _menhir_run_213 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState058 ->
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_416 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_KEYFRAMES_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_LEFT_BRACE, ttv_result) _menhir_cell1_keyframe _menhir_cell0_RIGHT_BRACE -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_RIGHT_BRACE (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_keyframe (_menhir_stack, _, x, _, _) = _menhir_stack in
      let MenhirCell1_LEFT_BRACE (_menhir_stack, _, _) = _menhir_stack in
      let _endpos__2_ = _endpos in
      let _v = _menhir_action_020 x in
      let _endpos = _endpos__2_ in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, i, _startpos_i_, _endpos_i_) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_KEYFRAMES_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let (_endpos_block_, block) = (_endpos, _v) in
      let _v = _menhir_action_009 _endpos_block_ _endpos_i_ _startpos_i_ _startpos_name_ block i name in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_at_rule : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_at_rule (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState421
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_422 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_237 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_LEFT_BRACE, ttv_result) _menhir_cell1_stylesheet_without_eof _menhir_cell0_RIGHT_BRACE -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_RIGHT_BRACE (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_stylesheet_without_eof (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell0_LEFT_BRACE (_menhir_stack, _) = _menhir_stack in
      let _v = _menhir_action_023 x in
      let _menhir_stack = MenhirCell0_brace_block_stylesheet_without_eof_ (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState246
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_247 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_247 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_brace_block_stylesheet_without_eof_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_brace_block_stylesheet_without_eof_ (_menhir_stack, s) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_prelude_ (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_RULE_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let _endpos__6_ = _endpos in
      let _v = _menhir_action_012 _endpos__6_ _startpos_name_ name s xs in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_229 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_STATEMENT_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_prelude_ (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_RULE_STATEMENT_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_011 _endpos__5_ _startpos_name_ name xs in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_218 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACE, ttv_result) _menhir_cell1_loc_declarations_ _menhir_cell0_RIGHT_BRACE -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell0_RIGHT_BRACE (_menhir_stack, _) = _menhir_stack in
      let MenhirCell1_loc_declarations_ (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_LEFT_BRACE (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let _endpos__2_ = _endpos in
      let _v = _menhir_action_021 x in
      _menhir_goto_brace_block_loc_declarations__ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _v _menhir_s _tok
  
  and _menhir_goto_brace_block_loc_declarations__ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState409 ->
          _menhir_run_410 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState405 ->
          _menhir_run_406 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState400 ->
          _menhir_run_402 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState378 ->
          _menhir_run_381 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState200 ->
          _menhir_run_222 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_410 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState410
      | EOF | IDENT _ | LEFT_BRACE | NUMBER _ | RIGHT_BRACE ->
          let _ = _menhir_action_161 () in
          _menhir_run_411 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_411 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___, ttv_result) _menhir_cell1_brace_block_loc_declarations__ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _, declarations, _) = _menhir_stack in
      let MenhirCell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ (_menhir_stack, _menhir_s, xs, _startpos_xs_, _endpos_xs_) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_057 _endpos__3_ _endpos_xs_ _startpos_xs_ declarations xs in
      _menhir_goto_keyframe_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_goto_keyframe_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 ->
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _menhir_stack = MenhirCell1_keyframe_style_rule (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState412
      | LEFT_BRACE ->
          let _menhir_stack = MenhirCell1_keyframe_style_rule (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState412 in
          let _v = _menhir_action_088 () in
          _menhir_goto_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v _menhir_s
      | EOF | RIGHT_BRACE ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_133 x in
          _menhir_goto_nonempty_list_keyframe_style_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok
      | IDENT _ | NUMBER _ ->
          let _menhir_stack = MenhirCell1_keyframe_style_rule (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _v_1 = _menhir_action_161 () in
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState412 _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ : 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 ->
      let _menhir_stack = MenhirCell1_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      _menhir_run_401 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState409
  
  and _menhir_run_401 : 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_BRACE (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState401
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_203 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState401 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_203 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACE 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState203
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState203 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_075 : 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState075
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | INTERPOLATION _v_1 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState075
      | IDENT _v_2 ->
          let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | COLON | WS ->
              let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_4, MenhirState075, _endpos_4, _startpos_3, _v_2) in
              let _v = _menhir_action_072 _endpos_x_ _startpos_x_ x in
              _menhir_goto_loc_IDENT_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s _tok
          | AMPERSAND | ASTERISK | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | TAG _ ->
              let (_endpos, _menhir_s, _startpos_type__, type_) = (_endpos_4, MenhirState075, _startpos_3, _v_2) in
              let _v = _menhir_action_220 type_ in
              _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_type__ _v _menhir_s _tok
          | _ ->
              _eRR ())
      | HASH _v_7 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState075
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | AT_RULE_STATEMENT _v_8 ->
          let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_10, MenhirState075, _endpos_10, _startpos_9, _v_8) in
          let _v = _menhir_action_070 _endpos_x_ _startpos_x_ x in
          let _startpos = _startpos_x_ in
          let _menhir_stack = MenhirCell1_loc_AT_RULE_STATEMENT_ (_menhir_stack, _menhir_s, _v, _startpos) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState223
          | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
              let _v_0 = _menhir_action_161 () in
              _menhir_run_224 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState223 _tok
          | _ ->
              _eRR ())
      | AT_RULE _v_12 ->
          let _startpos_13 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_14, MenhirState075, _endpos_14, _startpos_13, _v_12) in
          let _v = _menhir_action_069 _endpos_x_ _startpos_x_ x in
          let _startpos = _startpos_x_ in
          let _menhir_stack = MenhirCell1_loc_AT_RULE_ (_menhir_stack, _menhir_s, _v, _startpos) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState230
          | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
              let _v_0 = _menhir_action_161 () in
              _menhir_run_231 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState230 _tok
          | _ ->
              _eRR ())
      | AT_MEDIA _v_16 ->
          let _startpos_17 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_18 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_18, MenhirState075, _endpos_18, _startpos_17, _v_16) in
          let _v = _menhir_action_068 _endpos_x_ _startpos_x_ x in
          let _startpos = _startpos_x_ in
          let _menhir_stack = MenhirCell1_loc_AT_MEDIA_ (_menhir_stack, _menhir_s, _v, _startpos) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState248
          | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
              let _v_0 = _menhir_action_161 () in
              _menhir_run_249 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState248 _tok
          | _ ->
              _eRR ())
      | AT_KEYFRAMES _v_20 ->
          let _startpos_21 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_22 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_22, MenhirState075, _endpos_22, _startpos_21, _v_20) in
          let _v = _menhir_action_067 _endpos_x_ _startpos_x_ x in
          let _startpos = _startpos_x_ in
          let _menhir_stack = MenhirCell1_loc_AT_KEYFRAMES_ (_menhir_stack, _menhir_s, _v, _startpos) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState385
          | IDENT _ ->
              let _v_0 = _menhir_action_161 () in
              _menhir_run_386 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState385 _tok
          | _ ->
              _eRR ())
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState075
      | _ ->
          _eRR ()
  
  and _menhir_run_076 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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 (_startpos_type__, type_) = (_startpos, _v) in
      let _v = _menhir_action_221 type_ in
      _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_type__ _v _menhir_s _tok
  
  and _menhir_goto_type_selector : 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
      | LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_type_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState125
      | HASH _v_0 ->
          let _menhir_stack = MenhirCell1_type_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState125
      | DOUBLE_COLON ->
          let _menhir_stack = MenhirCell1_type_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState125
      | DOT ->
          let _menhir_stack = MenhirCell1_type_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState125
      | COLON ->
          let _menhir_stack = MenhirCell1_type_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState125
      | AMPERSAND | ASTERISK | COMBINATOR _ | COMMA | IDENT _ | INTERPOLATION _ | LEFT_BRACE | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ | WS ->
          let (_startpos_t_, t) = (_startpos, _v) in
          let _v = _menhir_action_198 t in
          _menhir_goto_simple_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_t_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_077 : 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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState077
      | IDENT _ | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_078 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState077 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_078 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, t) = (_endpos_2, _v_0) in
          let _v = _menhir_action_249 t in
          _menhir_goto_wq_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | IDENT _v_4 ->
          let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, i) = (_endpos_6, _v_4) in
          let _v = _menhir_action_248 i in
          _menhir_goto_wq_name _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_wq_name : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let _menhir_stack = MenhirCell0_wq_name (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState081
      | EQUAL_SIGN _ | OPERATOR _ | RIGHT_BRACKET ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_082 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState081 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_082 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_wq_name as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | RIGHT_BRACKET ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_wq_name (_menhir_stack, i) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos = _endpos_0 in
          let _v = _menhir_action_015 i in
          _menhir_goto_attribute_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | OPERATOR _v_1 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, o) = (_endpos_3, _v_1) in
          let _v = _menhir_action_013 o in
          _menhir_goto_attr_matcher _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | EQUAL_SIGN _v_5 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, eq) = (_endpos_6, _v_5) in
          let _v = _menhir_action_014 eq in
          _menhir_goto_attr_matcher _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_attribute_selector : 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_a_, a) = (_startpos, _v) in
      let _v = _menhir_action_214 a in
      _menhir_goto_subclass_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_a_ _v _menhir_s _tok
  
  and _menhir_goto_subclass_selector : 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
      | LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_subclass_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState126
      | HASH _v_0 ->
          let _menhir_stack = MenhirCell1_subclass_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState126
      | DOT ->
          let _menhir_stack = MenhirCell1_subclass_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState126
      | COLON ->
          let _menhir_stack = MenhirCell1_subclass_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState126
      | AMPERSAND | ASTERISK | COMBINATOR _ | COMMA | DOUBLE_COLON | IDENT _ | INTERPOLATION _ | LEFT_BRACE | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ | WS ->
          let (_startpos_x_, x) = (_startpos, _v) in
          let _v = _menhir_action_145 x in
          _menhir_goto_nonempty_list_subclass_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_096 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_h_, h) = (_startpos, _v) in
      let _v = _menhir_action_052 h in
      let _startpos = _startpos_h_ in
      let (_startpos_id_, id) = (_startpos, _v) in
      let _v = _menhir_action_212 id in
      _menhir_goto_subclass_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_id_ _v _menhir_s _tok
  
  and _menhir_run_099 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TAG _v ->
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _startpos__1_, tag) = (_endpos_1, _startpos, _v) in
          let _v = _menhir_action_026 tag in
          _menhir_goto_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | INTERPOLATION _v ->
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _startpos__1_, v) = (_endpos_3, _startpos, _v) in
          let _v = _menhir_action_216 v in
          _menhir_goto_subclass_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | IDENT _v ->
          let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _startpos__1_, id) = (_endpos_5, _startpos, _v) in
          let _v = _menhir_action_025 id in
          _menhir_goto_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_class_selector : 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_c_, c) = (_startpos, _v) in
      let _v = _menhir_action_213 c in
      _menhir_goto_subclass_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_c_ _v _menhir_s _tok
  
  and _menhir_run_103 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NTH_FUNCTION _v ->
          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, _menhir_s, _startpos, _endpos) in
          let _menhir_stack = MenhirCell0_NTH_FUNCTION (_menhir_stack, _v) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NUMBER _v_0 ->
              let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (_endpos_a_, _startpos_a_, a) = (_endpos_2, _startpos_1, _v_0) in
              let _v = _menhir_action_150 a in
              _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_a_ _startpos_a_ _v _tok
          | IDENT _v_4 ->
              let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_4, _startpos_5, _endpos_6) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | WS ->
                  _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState106
              | COMBINATOR _ | RIGHT_PAREN ->
                  let _ = _menhir_action_161 () in
                  _menhir_run_107 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_6 _tok
              | _ ->
                  _eRR ())
          | DIMENSION _v_8 ->
              let _startpos_9 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_10 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | WS ->
                  let _menhir_stack = MenhirCell0_DIMENSION (_menhir_stack, _v_8, _startpos_9, _endpos_10) in
                  _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState110
              | RIGHT_PAREN ->
                  let (_endpos_a_, _startpos_a_, a) = (_endpos_10, _startpos_9, _v_8) in
                  let _v = _menhir_action_151 a in
                  _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_a_ _startpos_a_ _v _tok
              | COMBINATOR _ | NUMBER _ ->
                  let _menhir_stack = MenhirCell0_DIMENSION (_menhir_stack, _v_8, _startpos_9, _endpos_10) in
                  let _ = _menhir_action_161 () in
                  _menhir_run_111 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | IDENT _v ->
          let _endpos_14 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _startpos__1_, i) = (_endpos_14, _startpos, _v) in
          let _v = _menhir_action_174 i in
          _menhir_goto_pseudo_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | FUNCTION _v ->
          let _menhir_stack = MenhirCell1_COLON (_menhir_stack, _menhir_s, _startpos, _endpos) in
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_FUNCTION (_menhir_stack, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState119 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TAG _v ->
              _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MEDIA_FEATURE_COMPARISON _v ->
              _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LEFT_BRACKET ->
              _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTERPOLATION _v ->
              _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | HASH _v ->
              _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DOUBLE_COLON ->
              _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | COMBINATOR _v ->
              _menhir_run_122 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COLON ->
              _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ASTERISK ->
              _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | AMPERSAND ->
              _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_nth_payload : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_NTH_FUNCTION -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_080 _endpos_x_ _startpos_x_ x in
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_NTH_FUNCTION (_menhir_stack, f) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _menhir_s, _startpos__1_, _) = _menhir_stack in
          let xs = _v in
          let _v = _menhir_action_177 f xs in
          _menhir_goto_pseudo_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_pseudo_class_selector : 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
      | MenhirState134 ->
          _menhir_run_134 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState133 ->
          _menhir_run_134 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState075 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState190 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState157 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState142 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState125 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState126 ->
          _menhir_run_127 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_134 : 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_pseudo_class_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState134
      | AMPERSAND | ASTERISK | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ | WS ->
          let _v_0 = _menhir_action_061 () in
          _menhir_run_135 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_135 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_pseudo_class_selector -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_pseudo_class_selector (_menhir_stack, _menhir_s, x, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_062 x xs in
      _menhir_goto_list_pseudo_class_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_list_pseudo_class_selector_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState133 ->
          _menhir_run_136 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState134 ->
          _menhir_run_135 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_136 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_pseudo_element_selector -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_pseudo_element_selector (_menhir_stack, _menhir_s, element, _startpos_element_) = _menhir_stack in
      let class_list = _v in
      let _v = _menhir_action_179 class_list element in
      _menhir_goto_pseudo_list _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_element_ _v _menhir_s _tok
  
  and _menhir_goto_pseudo_list : 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
      | MenhirState145 ->
          _menhir_run_146 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState075 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState190 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState157 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState142 ->
          _menhir_run_144 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState125 ->
          _menhir_run_132 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_146 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_nonempty_list_subclass_selector_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_nonempty_list_subclass_selector_ (_menhir_stack, _menhir_s, sub, _startpos_sub_) = _menhir_stack in
      let ps = _v in
      let _v = _menhir_action_038 ps sub in
      _menhir_goto_compound_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_sub_ _v _menhir_s _tok
  
  and _menhir_goto_compound_selector : 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
      | MenhirState075 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState190 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_175 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState157 ->
          _menhir_run_160 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_152 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_152 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_152 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState142 ->
          _menhir_run_147 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_175 : 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_compound_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState175
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_176 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState175 _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_176 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_compound_selector as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | WS ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_142 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | TAG _v_0 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState176
      | MEDIA_FEATURE_COMPARISON _v_1 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState176
      | LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | INTERPOLATION _v_2 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState176
      | IDENT _v_3 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState176
      | HASH _v_4 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState176
      | DOUBLE_COLON ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | DOT ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | COMBINATOR _v_5 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_122 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState176
      | COLON ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | ASTERISK ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | AMPERSAND ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState176
      | COMMA | LEFT_BRACE | RIGHT_PAREN ->
          let MenhirCell1_compound_selector (_menhir_stack, _menhir_s, s, _startpos_s_) = _menhir_stack in
          let _v = _menhir_action_207 s in
          _menhir_goto_skip_ws_right_non_complex_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_s_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_142 : 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_WS (_menhir_stack, _menhir_s, _startpos, _endpos) in
      let _menhir_s = MenhirState142 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TAG _v ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | INTERPOLATION _v ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | IDENT _v ->
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | HASH _v ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_094 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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 (_startpos_v_, v) = (_startpos, _v) in
      let _v = _menhir_action_219 v in
      _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_v_ _v _menhir_s _tok
  
  and _menhir_run_121 : 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 (_startpos_type__, type_) = (_startpos, _v) in
      let _v = _menhir_action_220 type_ in
      _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_type__ _v _menhir_s _tok
  
  and _menhir_run_097 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | IDENT _v ->
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _startpos__1_, pse) = (_endpos_1, _startpos, _v) in
          let _v = _menhir_action_178 pse in
          let _startpos = _startpos__1_ in
          let _menhir_stack = MenhirCell1_pseudo_element_selector (_menhir_stack, _menhir_s, _v, _startpos) in
          (match (_tok : MenhirBasics.token) with
          | COLON ->
              _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState133
          | AMPERSAND | ASTERISK | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ | WS ->
              let _v_0 = _menhir_action_061 () in
              _menhir_run_136 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_123 : 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 _startpos__1_ = _startpos in
      let _v = _menhir_action_218 () in
      _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_124 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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 _startpos__1_ = _startpos in
      let _v = _menhir_action_217 () in
      _menhir_goto_type_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_120 : 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 (_startpos_gt_, gt) = (_startpos, _v) in
      let _v = _menhir_action_051 gt in
      _menhir_goto_greater_than _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_gt_ _v _menhir_s _tok
  
  and _menhir_goto_greater_than : 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
      | MenhirState311 ->
          _menhir_run_272 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState323 ->
          _menhir_run_272 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState259 ->
          _menhir_run_272 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_151 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_272 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_greater_than (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | EQUAL_SIGN _v_0 ->
          _menhir_run_261 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState272
      | WS ->
          let _ = _menhir_action_165 () in
          _menhir_run_273 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_261 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let eq = _v in
      let _v = _menhir_action_050 eq in
      _menhir_goto_equal_sign _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_equal_sign : 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
      | MenhirState311 ->
          _menhir_run_274 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState259 ->
          _menhir_run_274 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState272 ->
          _menhir_run_271 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState269 ->
          _menhir_run_271 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_274 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let mfeq = _v in
      let _v = _menhir_action_121 mfeq in
      _menhir_goto_mf_comparison _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mf_comparison : 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
      | MenhirState311 ->
          _menhir_run_327 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState259 ->
          _menhir_run_264 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_327 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _ ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
              let MenhirCell1_mf_value (_menhir_stack, _menhir_s, _) = _menhir_stack in
              let xs = _v in
              let _v = _menhir_action_126 xs in
              _menhir_goto_mf_range _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_mf_range : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let mfr = _v in
      let _v = _menhir_action_101 mfr in
      _menhir_goto_media_feature _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_media_feature : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_media_feature (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState333
      | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_334 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_334 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_media_feature -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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_media_feature (_menhir_stack, _, mf) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell1_LEFT_PAREN (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos = _endpos_0 in
          let _v = _menhir_action_103 mf in
          _menhir_goto_media_in_parens _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_media_in_parens : 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
      | MenhirState342 ->
          _menhir_run_343 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState383 ->
          _menhir_run_339 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState249 ->
          _menhir_run_339 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState251 ->
          _menhir_run_339 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState298 ->
          _menhir_run_299 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | MenhirState285 ->
          _menhir_run_293 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState288 ->
          _menhir_run_289 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_343 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_or_operator -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_or_operator (_menhir_stack, _menhir_s, xs) = _menhir_stack in
      let _v = _menhir_action_106 xs in
      let _menhir_stack = MenhirCell1_media_or (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_menhir_s, o) = (MenhirState345, _v_0) in
          let _v = _menhir_action_169 o in
          let _menhir_stack = MenhirCell1_or_operator (_menhir_stack, _menhir_s, _v) in
          (match (_tok : MenhirBasics.token) with
          | LEFT_PAREN ->
              _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState342
          | INTERPOLATION _v_0 ->
              _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState342
          | _ ->
              _eRR ())
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_2 = _menhir_action_107 () in
          _menhir_run_347 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_2 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_251 : 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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState251
      | LEFT_PAREN ->
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState251
      | INTERPOLATION _v ->
          _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v MenhirState251
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | LEFT_BRACKET | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_253 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState251 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_252 : 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 (_startpos_v_, v) = (_startpos, _v) in
      let _v = _menhir_action_053 v in
      _menhir_goto_interpolation _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_v_ _v _menhir_s _tok
  
  and _menhir_goto_interpolation : 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
      | MenhirState249 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState383 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState251 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState342 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState285 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState298 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState288 ->
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState253 ->
          _menhir_run_268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState325 ->
          _menhir_run_268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState318 ->
          _menhir_run_268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState277 ->
          _menhir_run_268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState265 ->
          _menhir_run_268 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_291 : 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_i_, i) = (_startpos, _v) in
      let _v = _menhir_action_104 i in
      _menhir_goto_media_in_parens _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_i_ _v _menhir_s _tok
  
  and _menhir_run_268 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let v = _v in
      let _v = _menhir_action_129 v in
      _menhir_goto_mf_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mf_value : 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
      | MenhirState325 ->
          _menhir_run_326 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState318 ->
          _menhir_run_319 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState253 ->
          _menhir_run_310 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState277 ->
          _menhir_run_278 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState265 ->
          _menhir_run_267 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_326 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_gt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_gt _menhir_cell0_WS -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_gt (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_gt (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_value (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let _v = _menhir_action_128 xs in
      _menhir_goto_mf_range _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_319 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_lt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_lt _menhir_cell0_WS -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_lt (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_lt (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_value (_menhir_stack, _menhir_s, _) = _menhir_stack in
      let _v = _menhir_action_127 xs in
      _menhir_goto_mf_range _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_310 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_value (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState311 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | MEDIA_FEATURE_COMPARISON _v ->
              _menhir_run_260 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | EQUAL_SIGN _v ->
              _menhir_run_261 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_260 : 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 (_startpos_gt_, gt) = (_startpos, _v) in
      let _v = _menhir_action_051 gt in
      _menhir_goto_greater_than _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_gt_ _v _menhir_s _tok
  
  and _menhir_run_278 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _menhir_s, mf, _, _) = _menhir_stack in
      let _v = _menhir_action_124 mf in
      let mfp = _v in
      let _v = _menhir_action_099 mfp in
      _menhir_goto_media_feature _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_267 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_WS, ttv_result) _menhir_cell1_mf_comparison _menhir_cell0_WS -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell0_WS (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_mf_comparison (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_WS (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _menhir_s, xs, _, _) = _menhir_stack in
      let _v = _menhir_action_125 xs in
      _menhir_goto_mf_range _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_253 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | URL _v_0 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState253
      | UNICODE_RANGE _v_1 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState253
      | TAG _v_2 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState253
      | STRING _v_3 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState253
      | SCREEN_MEDIA_TYPE _v_4 ->
          let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, smt) = (_endpos_6, MenhirState253, _v_4) in
          let _v = _menhir_action_184 smt in
          _menhir_goto_screen_media_type _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | PRINT_MEDIA_TYPE _v_8 ->
          _menhir_run_255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState253
      | OPERATOR _v_9 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState253
      | NUMBER _v_10 ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState253
      | MEDIA_QUERY_OPERATOR _v_11 ->
          let _startpos_12 = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | INTERPOLATION _ | LEFT_PAREN ->
              let _v_14 =
                let n = _v_11 in
                _menhir_action_147 n
              in
              _menhir_run_288 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_12 _v_14 MenhirState253 _tok
          | WS ->
              let _v_15 =
                let mq_operator = _v_11 in
                _menhir_action_244 mq_operator
              in
              _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 MenhirState253 _tok
          | _ ->
              _eRR ())
      | LEFT_PAREN ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | LEFT_BRACKET ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | INTERPOLATION _v_16 ->
          _menhir_run_257 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 MenhirState253
      | IDENT _v_17 ->
          let _startpos_18 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_19 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState253, _v_17, _startpos_18, _endpos_19) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              let _startpos_20 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_21 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | MEDIA_FEATURE_COMPARISON _v_22 ->
                  let _menhir_stack = MenhirCell1_WS (_menhir_stack, MenhirState258, _startpos_20, _endpos_21) in
                  _menhir_run_260 _menhir_stack _menhir_lexbuf _menhir_lexer _v_22 MenhirState259
              | EQUAL_SIGN _v_23 ->
                  let _menhir_stack = MenhirCell1_WS (_menhir_stack, MenhirState258, _startpos_20, _endpos_21) in
                  _menhir_run_261 _menhir_stack _menhir_lexbuf _menhir_lexer _v_23 MenhirState259
              | COLON | RIGHT_PAREN | WS ->
                  let _v_24 =
                    let x = () in
                    _menhir_action_162 x
                  in
                  _menhir_run_275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_21 _startpos_20 _v_24 MenhirState258 _tok
              | _ ->
                  _eRR ())
          | COLON | RIGHT_PAREN ->
              let _v_25 = _menhir_action_161 () in
              _menhir_run_275 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_19 _endpos_19 _v_25 MenhirState258 _tok
          | _ ->
              _eRR ())
      | HASH _v_26 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_26 MenhirState253
      | FUNCTION _v_27 ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_27 MenhirState253
      | FLOAT_DIMENSION _v_28 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_28 MenhirState253
      | DOUBLE_COLON ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | DOT ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | DIMENSION _v_29 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_29 MenhirState253
      | DELIM _v_30 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_30 MenhirState253
      | COMMA ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | COMBINATOR _v_31 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_31 MenhirState253
      | COLON ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | ASTERISK ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState253
      | ALL_MEDIA_TYPE _v_32 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v_35 =
            let amt = _v_32 in
            _menhir_action_004 amt
          in
          let (_v, _menhir_s) = (_v_35, MenhirState253) in
          let _menhir_stack = MenhirCell1_all_media_type (_menhir_stack, _menhir_s, _v) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState336
          | RIGHT_PAREN ->
              let _ = _menhir_action_161 () in
              _menhir_run_337 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_014 : 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_243 u in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_u_ _startpos_u_ _v _menhir_s _tok
  
  and _menhir_goto_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 ->
      match _menhir_s with
      | MenhirState325 ->
          _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState318 ->
          _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState253 ->
          _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState277 ->
          _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState265 ->
          _menhir_run_266 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState231 ->
          _menhir_run_225 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState224 ->
          _menhir_run_225 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState013 ->
          _menhir_run_046 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_266 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let v = _v in
      let _v = _menhir_action_130 v in
      _menhir_goto_mf_value _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_225 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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_172 xs in
      let (_endpos, _startpos) = (_endpos_xs_, _startpos_xs_) in
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_081 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_prelude_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_loc_prelude_ : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState231 ->
          _menhir_run_232 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState224 ->
          _menhir_run_227 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_232 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_prelude_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState232
      | LEFT_BRACE ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_233 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState232 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_233 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_LEFT_BRACE (_menhir_stack, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState234
          | RIGHT_BRACE ->
              let _v_2 = _menhir_action_063 () in
              _menhir_run_245 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState234 _tok
          | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
              let _v_3 = _menhir_action_161 () in
              _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_3 MenhirState234 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_227 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_STATEMENT_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_prelude_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState227
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_228 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState227 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_228 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_STATEMENT_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_prelude_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SEMI_COLON ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState228
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | TAG _ | WS ->
          let _ = _menhir_action_159 () in
          _menhir_run_229 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_046 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ 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_value (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState046
      | ALL_MEDIA_TYPE _ | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | EOF | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | IMPORTANT | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | SEMI_COLON | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_047 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_047 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_value -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_value (_menhir_stack, _, x, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_203 x in
      let (_endpos, _startpos) = (_endpos__3_, _startpos__1_) in
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_086 _endpos_x_ _startpos_x_ x in
      let (_endpos, _startpos) = (_endpos_x_, _startpos_x_) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _menhir_stack = MenhirCell1_loc_skip_ws_value__ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState027
      | AMPERSAND | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | EOF | IMPORTANT | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SEMI_COLON ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_137 x in
          _menhir_goto_nonempty_list_loc_skip_ws_value___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _menhir_stack = MenhirCell1_loc_skip_ws_value__ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState027 _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_loc_skip_ws_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 ->
      match _menhir_s with
      | MenhirState027 ->
          _menhir_run_028 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState010 ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState050 ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState029 ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState023 ->
          _menhir_run_026 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_028 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_loc_skip_ws_value__ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_loc_skip_ws_value__ (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_138 x xs in
      _menhir_goto_nonempty_list_loc_skip_ws_value___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_run_026 : 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_247 xs in
      _menhir_goto_values _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_goto_values : 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
      | MenhirState029 ->
          _menhir_run_030 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState023 ->
          _menhir_run_024 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState050 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState010 ->
          _menhir_run_011 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_030 : 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 (x, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_024 x in
          let (_endpos, _startpos) = (_endpos__3_, _startpos__1_) in
          let (_endpos_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_223 b in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_024 : 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 (x, _endpos__3_) = (_v, _endpos_0) in
          let _v = _menhir_action_170 x in
          let (_endpos, _startpos) = (_endpos__3_, _startpos__1_) in
          let (_endpos_b_, _startpos_b_, b) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_222 b in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_b_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_011 : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_087 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_values_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_loc_values_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState010 ->
          _menhir_run_054 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState050 ->
          _menhir_run_051 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_054 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_values_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | IMPORTANT | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_055 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState054 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_055 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_values_ 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_option_WS_ (_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_019 () in
          _menhir_goto_boption_IMPORTANT_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ | WS ->
          let _v = _menhir_action_018 () 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_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_values_, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_073 _endpos_x_ _startpos_x_ x in
      let _menhir_stack = MenhirCell0_loc_boption_IMPORTANT__ (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState057
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_058 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState057 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_058 : type  ttv_stack ttv_result. (((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_values_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_loc_boption_IMPORTANT__ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SEMI_COLON ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState058
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | TAG _ | WS ->
          let _ = _menhir_action_159 () in
          _menhir_run_060 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_060 : type  ttv_stack ttv_result. (((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COLON, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_values_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_loc_boption_IMPORTANT__, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_loc_boption_IMPORTANT__ (_menhir_stack, important) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_values_ (_menhir_stack, _, value) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_IDENT_ (_menhir_stack, _menhir_s, property, _startpos_property_) = _menhir_stack in
      let _endpos__9_ = _endpos in
      let _v = _menhir_action_046 _endpos__9_ _startpos_property_ important property value in
      _menhir_goto_declaration_without_eof _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_declaration_without_eof : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState075 ->
          _menhir_run_419 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState005 ->
          _menhir_run_062 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_419 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_declaration_without_eof (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState419
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_420 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_420 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_declaration_without_eof -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_declaration_without_eof (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _v = _menhir_action_200 x in
      _menhir_goto_skip_ws_declaration_without_eof_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_skip_ws_declaration_without_eof_ : 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
      | MenhirState439 ->
          _menhir_run_239 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState234 ->
          _menhir_run_239 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState240 ->
          _menhir_run_239 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState239 ->
          _menhir_run_239 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState238 ->
          _menhir_run_239 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState067 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState211 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState204 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState207 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState206 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState205 ->
          _menhir_run_206 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState065 ->
          _menhir_run_204 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_204 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_070 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState071 ->
          _menhir_run_070 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState068 ->
          _menhir_run_070 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_239 : 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_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState239
      | EOF | RIGHT_BRACE ->
          let _v_0 = _menhir_action_063 () in
          _menhir_run_242 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_1 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState239 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_242 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_declaration_without_eof_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, d, _startpos_d_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_064 d xs in
      _menhir_goto_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_206 : 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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState206
      | EOF | RIGHT_BRACE | SEMI_COLON ->
          let d = _v in
          let _v = _menhir_action_139 d in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState206 _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_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 _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState065 ->
          _menhir_run_214 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_214 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState067 ->
          _menhir_run_210 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState205 ->
          _menhir_run_210 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState204 ->
          _menhir_run_209 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState206 ->
          _menhir_run_209 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState211 ->
          _menhir_run_208 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState207 ->
          _menhir_run_208 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_214 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_nonempty_list_rule_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | SEMI_COLON ->
          _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState214
      | EOF | RIGHT_BRACE ->
          let _ = _menhir_action_159 () in
          _menhir_run_215 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_215 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_nonempty_list_rule_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_nonempty_list_rule_ (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_047 xs in
      _menhir_goto_declarations _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_074 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_declarations_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_loc_declarations_ : 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
      | MenhirState064 ->
          _menhir_run_425 _menhir_stack _v _tok
      | MenhirState401 ->
          _menhir_run_216 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState201 ->
          _menhir_run_216 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_216 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACE as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_declarations_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_RIGHT_BRACE (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEMI_COLON ->
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState217
          | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | NUMBER _ | RIGHT_BRACE | TAG _ | WS ->
              let _ = _menhir_action_159 () in
              _menhir_run_218 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_210 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_style_rule_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_144 s xs in
      _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_209 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_declaration_without_eof_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, d, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_142 d xs in
      _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_208 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_at_rule_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, r, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_143 r xs in
      _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_204 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState204
      | SEMI_COLON ->
          let _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_071 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState204
      | EOF | RIGHT_BRACE ->
          let d = _v in
          let _v = _menhir_action_139 d in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState204 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_071 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_declaration_without_eof_ as 'stack) -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_SEMI_COLON (_menhir_stack, _menhir_s, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState071
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState071 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_070 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_SEMI_COLON as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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 _menhir_stack = MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_071 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState070
      | EOF | RIGHT_BRACE ->
          let d = _v in
          let _v = _menhir_action_192 d in
          _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState068 ->
          _menhir_run_424 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState071 ->
          _menhir_run_423 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState065 ->
          _menhir_run_212 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_212 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_074 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_424 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_style_rule_, ttv_result) _menhir_cell1_SEMI_COLON -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_SEMI_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, s, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_197 s xs in
      _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_423 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_declaration_without_eof_, ttv_result) _menhir_cell1_SEMI_COLON -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_SEMI_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_skip_ws_declaration_without_eof_ (_menhir_stack, _menhir_s, d, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_195 d xs in
      _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_212 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_separated_nonempty_list_SEMI_COLON_rule_ (_menhir_stack, _menhir_s, _v) in
      let _ = _menhir_action_159 () in
      _menhir_run_213 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_run_213 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_separated_nonempty_list_SEMI_COLON_rule_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_separated_nonempty_list_SEMI_COLON_rule_ (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_048 xs in
      _menhir_goto_declarations _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_074 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_at_rule_, ttv_result) _menhir_cell1_SEMI_COLON -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_SEMI_COLON (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, r, _) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_196 r xs in
      _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_062 : type  ttv_stack. (ttv_stack, _menhir_box_declaration) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _menhir_box_declaration =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _, _) = _menhir_stack in
      let x = _v in
      let _v = _menhir_action_204 x in
      let _menhir_stack = MenhirCell1_skip_ws_left_declaration_without_eof_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState002
      | EOF ->
          let _ = _menhir_action_161 () in
          _menhir_run_003 _menhir_stack _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_051 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_loc_FUNCTION_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_loc_FUNCTION_ (_menhir_stack, _menhir_s, f, _startpos_f_) = _menhir_stack in
          let (_endpos__3_, v) = (_endpos, _v) in
          let _v = _menhir_action_242 f v in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos_f_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_013 : 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | URL _v_0 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState013
      | UNICODE_RANGE _v_1 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState013
      | TAG _v_2 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState013
      | STRING _v_3 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState013
      | SCREEN_MEDIA_TYPE _v_4 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState013
      | OPERATOR _v_5 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState013
      | NUMBER _v_6 ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState013
      | MEDIA_QUERY_OPERATOR _v_7 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState013
      | LEFT_PAREN ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | LEFT_BRACKET ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | INTERPOLATION _v_8 ->
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState013
      | IDENT _v_9 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState013
      | HASH _v_10 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState013
      | FUNCTION _v_11 ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState013
      | FLOAT_DIMENSION _v_12 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState013
      | DOUBLE_COLON ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | DOT ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | DIMENSION _v_13 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState013
      | DELIM _v_14 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 MenhirState013
      | COMMA ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | COMBINATOR _v_15 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 MenhirState013
      | COLON ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | ASTERISK ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState013
      | ALL_MEDIA_TYPE _v_16 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 MenhirState013
      | _ ->
          _eRR ()
  
  and _menhir_run_015 : 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_238 r in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_r_ _startpos_r_ _v _menhir_s _tok
  
  and _menhir_run_016 : 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_226 i in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok
  
  and _menhir_run_017 : 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_227 s in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_s_ _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_018 : 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_screen_, _startpos_screen_, screen) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_246 screen in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_screen_ _startpos_screen_ _v _menhir_s _tok
  
  and _menhir_run_019 : 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_229 o in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_o_ _startpos_o_ _v _menhir_s _tok
  
  and _menhir_run_020 : 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
      | PERCENT ->
          let _menhir_stack = MenhirCell1_NUMBER (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_021 _menhir_stack _menhir_lexbuf _menhir_lexer
      | ALL_MEDIA_TYPE _ | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | EOF | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | IMPORTANT | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | RIGHT_BRACE | RIGHT_BRACKET | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | SEMI_COLON | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ | WS ->
          let (_endpos_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_237 n in
          _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_021 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_NUMBER -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_NUMBER (_menhir_stack, _menhir_s, n, _startpos_n_, _) = _menhir_stack in
      let _endpos__2_ = _endpos in
      let _v = _menhir_action_171 n in
      _menhir_goto_percentage _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_n_ _v _menhir_s _tok
  
  and _menhir_goto_percentage : 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
      | MenhirState398 ->
          _menhir_run_404 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState393 ->
          _menhir_run_395 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState325 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState318 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState253 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState277 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState265 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState231 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState224 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState013 ->
          _menhir_run_048 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_404 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ 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_percentage (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState404
      | COMMA | LEFT_BRACE ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_405 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState404 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_405 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_percentage as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | LEFT_BRACE ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_401 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState405
      | COMMA ->
          let MenhirCell1_percentage (_menhir_stack, _, x, _, _) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
          let _endpos__3_ = _endpos in
          let _v = _menhir_action_201 x in
          _menhir_goto_skip_ws_percentage_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_skip_ws_percentage_ : 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
      | COMMA ->
          let _menhir_stack = MenhirCell1_skip_ws_percentage_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _startpos_0, _endpos_1) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState391
          | NUMBER _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_393 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState391 _tok
          | _ ->
              _eRR ())
      | LEFT_BRACE ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_190 x in
          _menhir_goto_separated_nonempty_list_COMMA_skip_ws_percentage__ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_393 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | NUMBER _v_0 ->
          _menhir_run_394 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState393
      | _ ->
          _eRR ()
  
  and _menhir_run_394 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('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_NUMBER (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | PERCENT ->
          _menhir_run_021 _menhir_stack _menhir_lexbuf _menhir_lexer
      | _ ->
          _eRR ()
  
  and _menhir_goto_separated_nonempty_list_COMMA_skip_ws_percentage__ : 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 ->
      match _menhir_s with
      | MenhirState428 ->
          _menhir_run_397 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s
      | MenhirState429 ->
          _menhir_run_397 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s
      | MenhirState412 ->
          _menhir_run_397 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s
      | MenhirState389 ->
          _menhir_run_397 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s
      | MenhirState391 ->
          _menhir_run_392 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_397 : 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 ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_089 x in
      _menhir_goto_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s
  
  and _menhir_run_392 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v ->
      let MenhirCell0_COMMA (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_skip_ws_percentage_ (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_191 x xs in
      _menhir_goto_separated_nonempty_list_COMMA_skip_ws_percentage__ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s
  
  and _menhir_run_395 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_ 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_percentage (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState395
      | COMMA | LEFT_BRACE ->
          let _ = _menhir_action_161 () in
          _menhir_run_396 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_396 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_skip_ws_percentage_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_percentage -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_percentage (_menhir_stack, _, x, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__3_ = _endpos in
      let _v = _menhir_action_201 x in
      _menhir_goto_skip_ws_percentage_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__3_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_048 : 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_n_, _startpos_n_, n) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_224 n in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_n_ _startpos_n_ _v _menhir_s _tok
  
  and _menhir_run_022 : 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_mq_operator_, _startpos_mq_operator_, mq_operator) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_244 mq_operator in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_mq_operator_ _startpos_mq_operator_ _v _menhir_s _tok
  
  and _menhir_run_023 : 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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState023
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState023 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_029 : 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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState029
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState029 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_032 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('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_v_, _startpos_v_, v) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_241 v in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_v_ _startpos_v_ _v _menhir_s _tok
  
  and _menhir_run_033 : 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_225 i in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_i_ _startpos_i_ _v _menhir_s _tok
  
  and _menhir_run_034 : 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_234 h in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_h_ _startpos_h_ _v _menhir_s _tok
  
  and _menhir_run_035 : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_071 _endpos_x_ _startpos_x_ x in
      let _startpos = _startpos_x_ in
      let _menhir_stack = MenhirCell1_loc_FUNCTION_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState050
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState050 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_036 : 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_239 d in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_037 : 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_235 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_038 : 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_231 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_039 : 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_240 d in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_040 : 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_230 d in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_d_ _startpos_d_ _v _menhir_s _tok
  
  and _menhir_run_041 : 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_236 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_042 : 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_c_, _startpos_c_, c) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_228 c in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_c_ _startpos_c_ _v _menhir_s _tok
  
  and _menhir_run_043 : 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_233 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_044 : 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_232 () in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__1_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_045 : 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_all_, _startpos_all_, all) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_245 all in
      _menhir_goto_value _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_all_ _startpos_all_ _v _menhir_s _tok
  
  and _menhir_goto_screen_media_type : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let mt = _v in
      let _v = _menhir_action_185 mt in
      _menhir_goto_screen_or_print_media_type _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_screen_or_print_media_type : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState353 ->
          _menhir_run_355 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState304 ->
          _menhir_run_306 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState253 ->
          _menhir_run_280 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_355 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState355
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_356 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState355 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_356 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          _menhir_run_357 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState356
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_0 = _menhir_action_157 () in
          _menhir_run_358 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState356 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_357 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let x = () in
      let _v = _menhir_action_158 x in
      _menhir_goto_option_COMMA_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_option_COMMA_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState374 ->
          _menhir_run_375 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState360 ->
          _menhir_run_361 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState356 ->
          _menhir_run_358 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_375 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_media_condition, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_COMMA_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState375
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_376 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_376 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_media_condition, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_COMMA_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_COMMA_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_media_condition (_menhir_stack, _menhir_s, mc, _startpos_mc_) = _menhir_stack in
      let _endpos__4_ = _endpos in
      let _v = _menhir_action_109 mc in
      _menhir_goto_media_query _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos_mc_ _v _menhir_s _tok
  
  and _menhir_goto_media_query : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_078 _endpos_x_ _startpos_x_ x in
      let (_endpos, _startpos) = (_endpos_x_, _startpos_x_) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _menhir_stack = MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState383
      | MEDIA_QUERY_OPERATOR _v_0 ->
          let _menhir_stack = MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState383
      | LEFT_PAREN ->
          let _menhir_stack = MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState383
      | INTERPOLATION _v_1 ->
          let _menhir_stack = MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState383
      | LEFT_BRACE ->
          let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
          let _v = _menhir_action_135 x in
          _menhir_goto_nonempty_list_loc_media_query__ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _startpos_x_ _v _menhir_s _tok
      | ALL_MEDIA_TYPE _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _menhir_stack = MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _menhir_s = MenhirState383 in
          let _v = _menhir_action_167 () in
          _menhir_goto_option_not_or_only_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_250 : 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 _tok = _menhir_lexer _menhir_lexbuf in
      let (_startpos_o_, o) = (_startpos, _v) in
      let _v = _menhir_action_156 o in
      let _startpos = _startpos_o_ in
      let (_startpos_o_, o) = (_startpos, _v) in
      let _v = _menhir_action_149 o in
      let _startpos = _startpos_o_ in
      let (_startpos_x_, x) = (_startpos, _v) in
      let _v = _menhir_action_168 x in
      _menhir_goto_option_not_or_only_ _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_option_not_or_only_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_not_or_only_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | SCREEN_MEDIA_TYPE _v_0 ->
          _menhir_run_305 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState353
      | PRINT_MEDIA_TYPE _v_1 ->
          _menhir_run_255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState353
      | ALL_MEDIA_TYPE _v_2 ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v_4 =
            let amt = _v_2 in
            _menhir_action_004 amt
          in
          let (_v, _menhir_s) = (_v_4, MenhirState353) in
          let _menhir_stack = MenhirCell1_all_media_type (_menhir_stack, _menhir_s, _v) in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState363
          | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
              let _v_0 = _menhir_action_161 () in
              _menhir_run_364 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState363 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_305 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let smt = _v in
      let _v = _menhir_action_184 smt in
      _menhir_goto_screen_media_type _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_255 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let pmt = _v in
      let _v = _menhir_action_173 pmt in
      let mt = _v in
      let _v = _menhir_action_186 mt in
      _menhir_goto_screen_or_print_media_type _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_364 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_all_media_type 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          _menhir_run_282 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState364
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_1 = _menhir_action_163 () in
          _menhir_run_365 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_1 MenhirState364 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_282 : 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 _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let a = _v in
      let _v = _menhir_action_006 a in
      _menhir_goto_and_operator _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_and_operator : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState340 ->
          _menhir_run_298 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState294 ->
          _menhir_run_298 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState296 ->
          _menhir_run_298 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState364 ->
          _menhir_run_285 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState359 ->
          _menhir_run_285 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState281 ->
          _menhir_run_285 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_298 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_and_operator (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LEFT_PAREN ->
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState298
      | INTERPOLATION _v_0 ->
          _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState298
      | _ ->
          _eRR ()
  
  and _menhir_run_285 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_and_operator (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState285
      | LEFT_PAREN ->
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState285
      | INTERPOLATION _v_0 ->
          _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState285
      | MEDIA_QUERY_OPERATOR _ ->
          let _v_1 = _menhir_action_161 () in
          _menhir_run_286 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState285 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_286 : 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v_3 =
            let n = _v_0 in
            _menhir_action_147 n
          in
          _menhir_run_288 _menhir_stack _menhir_lexbuf _menhir_lexer _startpos_1 _v_3 MenhirState286 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_288 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ 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_not_operator (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_PAREN ->
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState288
      | INTERPOLATION _v_0 ->
          _menhir_run_252 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState288
      | _ ->
          _eRR ()
  
  and _menhir_run_365 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_all_media_type, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState365
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_366 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_366 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_all_media_type, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_and_media_condition_without_or_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_all_media_type (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_not_or_only_ (_menhir_stack, _menhir_s, _, _startpos__1_) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_111 xs in
      _menhir_goto_media_query _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_nonempty_list_loc_media_query__ : 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
      | MenhirState383 ->
          _menhir_run_384 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState249 ->
          _menhir_run_370 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_384 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_loc_media_query_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_loc_media_query_ (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_136 x xs in
      _menhir_goto_nonempty_list_loc_media_query__ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_run_370 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_mq_, _startpos_mq_, mq) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_113 mq in
      let (_endpos, _startpos) = (_endpos_mq_, _startpos_mq_) in
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_079 _endpos_x_ _startpos_x_ x in
      let _menhir_stack = MenhirCell1_loc_media_query_prelude_ (_menhir_stack, _menhir_s, _v) in
      let _v_0 = _menhir_action_161 () in
      _menhir_run_378 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState377 _tok
  
  and _menhir_run_378 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_media_query_prelude_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          _menhir_run_201 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState378
      | _ ->
          _eRR ()
  
  and _menhir_run_201 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> ('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_BRACE (_menhir_stack, _menhir_s, _startpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState201
      | RIGHT_BRACE ->
          _menhir_run_202 _menhir_stack _menhir_lexbuf _menhir_lexer
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_203 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState201 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_202 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_LEFT_BRACE -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_LEFT_BRACE (_menhir_stack, _menhir_s, _startpos_x_) = _menhir_stack in
      let (x, _endpos_y_, y) = ((), _endpos, ()) in
      let _v = _menhir_action_049 x y in
      let (_endpos, _startpos) = (_endpos_y_, _startpos_x_) in
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_075 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_empty_brace_block_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_loc_empty_brace_block_ : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState388 ->
          _menhir_run_417 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState378 ->
          _menhir_run_379 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState200 ->
          _menhir_run_220 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_417 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_KEYFRAMES_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_IDENT (_menhir_stack, i, _startpos_i_, _endpos_i_) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_KEYFRAMES_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let (_endpos_s_, s) = (_endpos, _v) in
      let _v = _menhir_action_010 _endpos_i_ _endpos_s_ _startpos_i_ _startpos_name_ i name s in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_379 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_media_query_prelude_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_empty_brace_block_ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState379
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_380 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_380 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_media_query_prelude_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_empty_brace_block_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_loc_empty_brace_block_ (_menhir_stack, _, b, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_media_query_prelude_ (_menhir_stack, _, prelude) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_MEDIA_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let _endpos__6_ = _endpos in
      let _v = _menhir_action_008 _endpos__6_ _startpos_name_ b name prelude in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_220 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_selector_list_, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_selector_list_ (_menhir_stack, _menhir_s, prelude, _startpos_prelude_) = _menhir_stack in
      let (_endpos_block_, block) = (_endpos, _v) in
      let _v = _menhir_action_208 _endpos_block_ _startpos_prelude_ block prelude in
      _menhir_goto_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_style_rule : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_style_rule (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState197
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_198 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_198 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_style_rule -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_style_rule (_menhir_stack, _, x) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _v = _menhir_action_202 x in
      _menhir_goto_skip_ws_style_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_skip_ws_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 ->
      match _menhir_s with
      | MenhirState439 ->
          _menhir_run_238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState240 ->
          _menhir_run_238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState239 ->
          _menhir_run_238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState238 ->
          _menhir_run_238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState234 ->
          _menhir_run_238 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState067 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState211 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState207 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState206 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState205 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState204 ->
          _menhir_run_205 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState073 ->
          _menhir_run_069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState071 ->
          _menhir_run_069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState068 ->
          _menhir_run_069 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState203 ->
          _menhir_run_067 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState065 ->
          _menhir_run_067 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_238 : 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_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState238
      | EOF | RIGHT_BRACE ->
          let _v_0 = _menhir_action_063 () in
          _menhir_run_243 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_1 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState238 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_243 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_skip_ws_style_rule_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, s, _startpos_s_) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_066 s xs in
      _menhir_goto_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_205 : 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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState205
      | EOF | RIGHT_BRACE | SEMI_COLON ->
          let s = _v in
          let _v = _menhir_action_141 s in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState205 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_069 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_SEMI_COLON as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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 _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState069
      | EOF | RIGHT_BRACE ->
          let s = _v in
          let _v = _menhir_action_194 s in
          _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_068 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_style_rule_ as 'stack) -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_SEMI_COLON (_menhir_stack, _menhir_s, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState068
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState068 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_067 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState067
      | SEMI_COLON ->
          let _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_068 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState067
      | EOF | RIGHT_BRACE ->
          let s = _v in
          let _v = _menhir_action_141 s in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_style_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState067 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_361 : type  ttv_stack ttv_result. (((((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_COMMA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_and_media_condition_without_or_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_COMMA_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState361
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_362 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_362 : type  ttv_stack ttv_result. (((((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_COMMA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_and_media_condition_without_or_, ttv_result) _menhir_cell1_option_COMMA_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_COMMA_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_option_COMMA_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_screen_or_print_media_type (_menhir_stack, _, xs) = _menhir_stack in
      let MenhirCell1_option_not_or_only_ (_menhir_stack, _menhir_s, _, _startpos__1_) = _menhir_stack in
      let _endpos__8_ = _endpos in
      let _v = _menhir_action_110 xs in
      _menhir_goto_media_query _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__8_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_358 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_COMMA_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState358
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_359 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState358 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_359 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_COMMA_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          _menhir_run_282 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState359
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_1 = _menhir_action_163 () in
          _menhir_run_360 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_1 MenhirState359 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_360 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_not_or_only_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_option_COMMA_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          _menhir_run_357 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState360
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_0 = _menhir_action_157 () in
          _menhir_run_361 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState360 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_306 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState306
      | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_307 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_307 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_screen_or_print_media_type (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_COMMA (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, mt) = _menhir_stack in
      let _v = _menhir_action_118 mt in
      _menhir_goto_mf_boolean _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mf_boolean : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let mfb = _v in
      let _v = _menhir_action_100 mfb in
      _menhir_goto_media_feature _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_280 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          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
          | MEDIA_QUERY_OPERATOR _v_0 ->
              let _menhir_stack = MenhirCell1_WS (_menhir_stack, MenhirState280, _startpos, _endpos) in
              _menhir_run_282 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState281
          | COMMA ->
              let _v_1 =
                let x = () in
                _menhir_action_162 x
              in
              _menhir_run_302 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v_1 MenhirState280 _tok
          | RIGHT_PAREN | WS ->
              let _menhir_stack = MenhirCell1_WS (_menhir_stack, MenhirState280, _startpos, _endpos) in
              let _v_2 = _menhir_action_163 () in
              _menhir_run_283 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState281 _tok
          | _ ->
              _eRR ())
      | COMMA | RIGHT_PAREN ->
          let _v_3 = _menhir_action_161 () in
          _menhir_run_302 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_3 MenhirState280 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_302 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | COMMA ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _startpos_0, _endpos_1) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState303
          | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_304 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState303 _tok
          | _ ->
              _eRR ())
      | RIGHT_PAREN | WS ->
          let MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, mt) = _menhir_stack in
          let _v = _menhir_action_116 mt in
          _menhir_goto_mf_boolean _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_304 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | SCREEN_MEDIA_TYPE _v_0 ->
          _menhir_run_305 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState304
      | PRINT_MEDIA_TYPE _v_1 ->
          _menhir_run_255 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState304
      | _ ->
          _eRR ()
  
  and _menhir_run_283 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState283
      | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_284 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_284 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_screen_or_print_media_type, ttv_result) _menhir_cell1_WS, ttv_result) _menhir_cell1_option_and_media_condition_without_or_ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_option_and_media_condition_without_or_ (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_WS (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_screen_or_print_media_type (_menhir_stack, _menhir_s, mt) = _menhir_stack in
      let _v = _menhir_action_117 mt in
      _menhir_goto_mf_boolean _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_257 : 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 (_startpos_v_, v) = (_startpos, _v) in
      let _v = _menhir_action_053 v in
      _menhir_goto_interpolation _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_v_ _v _menhir_s _tok
  
  and _menhir_run_275 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | COLON ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          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
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState276
          | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_277 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState276 _tok
          | _ ->
              _eRR ())
      | RIGHT_PAREN | WS ->
          let MenhirCell1_IDENT (_menhir_stack, _menhir_s, i, _, _) = _menhir_stack in
          let _v = _menhir_action_114 i in
          _menhir_goto_mf_boolean _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_277 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WS_ _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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | URL _v_0 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState277
      | UNICODE_RANGE _v_1 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState277
      | TAG _v_2 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState277
      | STRING _v_3 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState277
      | SCREEN_MEDIA_TYPE _v_4 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState277
      | OPERATOR _v_5 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState277
      | NUMBER _v_6 ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState277
      | MEDIA_QUERY_OPERATOR _v_7 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState277
      | LEFT_PAREN ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | LEFT_BRACKET ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | INTERPOLATION _v_8 ->
          _menhir_run_257 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState277
      | IDENT _v_9 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState277
      | HASH _v_10 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState277
      | FUNCTION _v_11 ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState277
      | FLOAT_DIMENSION _v_12 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState277
      | DOUBLE_COLON ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | DOT ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | DIMENSION _v_13 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState277
      | DELIM _v_14 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 MenhirState277
      | COMMA ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | COMBINATOR _v_15 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 MenhirState277
      | COLON ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | ASTERISK ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState277
      | ALL_MEDIA_TYPE _v_16 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 MenhirState277
      | _ ->
          _eRR ()
  
  and _menhir_run_337 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_all_media_type -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_all_media_type (_menhir_stack, _menhir_s, all_mt) = _menhir_stack in
      let _v = _menhir_action_115 all_mt in
      _menhir_goto_mf_boolean _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_347 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_media_or -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_media_or (_menhir_stack, _menhir_s, or_rule) = _menhir_stack in
      let rest = _v in
      let _v = _menhir_action_108 or_rule rest in
      _menhir_goto_media_or_star _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_media_or_star : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState345 ->
          _menhir_run_347 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState340 ->
          _menhir_run_344 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_344 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_media_in_parens, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let xs = _v in
      let _ = _menhir_action_092 xs in
      _menhir_goto_media_and_or_star _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_goto_media_and_or_star : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_media_in_parens, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_media_in_parens (_menhir_stack, _menhir_s, xs, _startpos_xs_) = _menhir_stack in
      let _v = _menhir_action_096 xs in
      _menhir_goto_media_condition _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_goto_media_condition : 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
      | MenhirState383 ->
          _menhir_run_373 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState249 ->
          _menhir_run_373 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState251 ->
          _menhir_run_350 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_373 : 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_media_condition (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState373
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_374 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState373 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_374 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_media_condition 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | COMMA ->
          _menhir_run_357 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState374
      | ALL_MEDIA_TYPE _ | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_0 = _menhir_action_157 () in
          _menhir_run_375 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_0 MenhirState374 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_350 : 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 = _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 mc = _v in
          let _v = _menhir_action_102 mc in
          _menhir_goto_media_in_parens _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_339 : 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_media_in_parens (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState339
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_340 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState339 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_340 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_media_in_parens 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v_3 =
            let a = _v_0 in
            _menhir_action_006 a
          in
          _menhir_run_298 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState340 _tok
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_4 = _menhir_action_093 () in
          _menhir_run_348 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_4 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_348 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_media_in_parens, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let xs = _v in
      let _ = _menhir_action_091 xs in
      _menhir_goto_media_and_or_star _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_run_299 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_and_operator -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_and_operator (_menhir_stack, _menhir_s, xs) = _menhir_stack in
      let _v = _menhir_action_090 xs in
      let _menhir_stack = MenhirCell1_media_and (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          _menhir_run_282 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState296
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | WS ->
          let _v_1 = _menhir_action_093 () in
          _menhir_run_297 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v_1 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_297 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_media_and -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_media_and (_menhir_stack, _menhir_s, and_rule) = _menhir_stack in
      let rest = _v in
      let _v = _menhir_action_094 and_rule rest in
      _menhir_goto_media_and_star _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_media_and_star : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState340 ->
          _menhir_run_348 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState296 ->
          _menhir_run_297 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState294 ->
          _menhir_run_295 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_295 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_and_operator, ttv_result) _menhir_cell1_media_in_parens, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_media_in_parens (_menhir_stack, _, xs, _) = _menhir_stack in
      let _ = _menhir_action_098 xs in
      _menhir_goto_media_condition_without_or _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_goto_media_condition_without_or : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_and_operator -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_and_operator (_menhir_stack, _menhir_s, xs) = _menhir_stack in
      let _v = _menhir_action_005 xs in
      let x = _v in
      let _v = _menhir_action_164 x in
      _menhir_goto_option_and_media_condition_without_or_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_option_and_media_condition_without_or_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState364 ->
          _menhir_run_365 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState359 ->
          _menhir_run_360 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | MenhirState281 ->
          _menhir_run_283 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_293 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_and_operator 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_media_in_parens (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState293
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_294 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState293 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_294 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_and_operator, ttv_result) _menhir_cell1_media_in_parens 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | MEDIA_QUERY_OPERATOR _v_0 ->
          _menhir_run_282 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState294
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ | WS ->
          let _ = _menhir_action_093 () in
          _menhir_run_295 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_289 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_not_operator 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_media_in_parens (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState289
      | ALL_MEDIA_TYPE _ | COMMA | INTERPOLATION _ | LEFT_BRACE | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | PRINT_MEDIA_TYPE _ | RIGHT_PAREN | SCREEN_MEDIA_TYPE _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_290 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_290 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_not_operator, ttv_result) _menhir_cell1_media_in_parens -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_media_in_parens (_menhir_stack, _, _, _) = _menhir_stack in
      let MenhirCell1_not_operator (_menhir_stack, _, mn, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _v = _menhir_action_105 mn in
      _menhir_goto_media_not _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
  
  and _menhir_goto_media_not : 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
      | MenhirState383 ->
          _menhir_run_338 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState249 ->
          _menhir_run_338 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState251 ->
          _menhir_run_338 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState285 ->
          _menhir_run_292 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_338 : 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_mn_, mn) = (_startpos, _v) in
      let _v = _menhir_action_095 mn in
      _menhir_goto_media_condition _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_mn_ _v _menhir_s _tok
  
  and _menhir_run_292 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_and_operator -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let mn = _v in
      let _ = _menhir_action_097 mn in
      _menhir_goto_media_condition_without_or _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_run_264 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_comparison (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState265 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | URL _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | UNICODE_RANGE _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | TAG _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SCREEN_MEDIA_TYPE _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | OPERATOR _v ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | NUMBER _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MEDIA_QUERY_OPERATOR _v ->
              _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LEFT_PAREN ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LEFT_BRACKET ->
              _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTERPOLATION _v ->
              _menhir_run_257 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | HASH _v ->
              _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNCTION _v ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FLOAT_DIMENSION _v ->
              _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DOUBLE_COLON ->
              _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DIMENSION _v ->
              _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DELIM _v ->
              _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMA ->
              _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | COMBINATOR _v ->
              _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COLON ->
              _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ASTERISK ->
              _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ALL_MEDIA_TYPE _v ->
              _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_271 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let x = _v in
      let _ = _menhir_action_166 x in
      _menhir_goto_option_equal_sign_ _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok
  
  and _menhir_goto_option_equal_sign_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s _tok ->
      match _menhir_s with
      | MenhirState272 ->
          _menhir_run_273 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | MenhirState269 ->
          _menhir_run_270 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_273 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_greater_than -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_greater_than (_menhir_stack, _menhir_s, mglt, _) = _menhir_stack in
      let _v = _menhir_action_122 mglt in
      _menhir_goto_mf_gt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mf_gt : 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
      | MenhirState323 ->
          _menhir_run_324 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState311 ->
          _menhir_run_320 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState259 ->
          _menhir_run_263 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_324 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_gt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_gt (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState325 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | URL _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | UNICODE_RANGE _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | TAG _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SCREEN_MEDIA_TYPE _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | OPERATOR _v ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | NUMBER _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MEDIA_QUERY_OPERATOR _v ->
              _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LEFT_PAREN ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LEFT_BRACKET ->
              _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTERPOLATION _v ->
              _menhir_run_257 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | HASH _v ->
              _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNCTION _v ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FLOAT_DIMENSION _v ->
              _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DOUBLE_COLON ->
              _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DIMENSION _v ->
              _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DELIM _v ->
              _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMA ->
              _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | COMBINATOR _v ->
              _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COLON ->
              _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ASTERISK ->
              _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ALL_MEDIA_TYPE _v ->
              _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_320 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_gt (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _v ->
              let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v, _startpos, _endpos) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | WS ->
                  let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
                  let _menhir_s = MenhirState323 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | MEDIA_FEATURE_COMPARISON _v ->
                      _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_263 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let mfgt = _v in
      let _v = _menhir_action_120 mfgt in
      _menhir_goto_mf_comparison _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_270 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_less_than -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      let MenhirCell1_less_than (_menhir_stack, _menhir_s, mflt) = _menhir_stack in
      let _v = _menhir_action_123 mflt in
      _menhir_goto_mf_lt _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_mf_lt : 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
      | MenhirState315 ->
          _menhir_run_317 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState311 ->
          _menhir_run_312 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState259 ->
          _menhir_run_262 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_317 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS, ttv_result) _menhir_cell1_mf_lt _menhir_cell0_WS _menhir_cell0_IDENT _menhir_cell0_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_lt (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _menhir_s = MenhirState318 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | URL _v ->
              _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | UNICODE_RANGE _v ->
              _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | TAG _v ->
              _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | STRING _v ->
              _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | SCREEN_MEDIA_TYPE _v ->
              _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | OPERATOR _v ->
              _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | NUMBER _v ->
              _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MEDIA_QUERY_OPERATOR _v ->
              _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | LEFT_PAREN ->
              _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | LEFT_BRACKET ->
              _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INTERPOLATION _v ->
              _menhir_run_257 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | IDENT _v ->
              _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | HASH _v ->
              _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FUNCTION _v ->
              _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | FLOAT_DIMENSION _v ->
              _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DOUBLE_COLON ->
              _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DOT ->
              _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | DIMENSION _v ->
              _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | DELIM _v ->
              _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COMMA ->
              _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | COMBINATOR _v ->
              _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | COLON ->
              _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ASTERISK ->
              _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ALL_MEDIA_TYPE _v ->
              _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_312 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_mf_value _menhir_cell0_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_mf_lt (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | IDENT _v_0 ->
              let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
              let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_0, _startpos_1, _endpos_2) in
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | WS ->
                  let _startpos_3 = _menhir_lexbuf.Lexing.lex_start_p in
                  let _endpos_4 = _menhir_lexbuf.Lexing.lex_curr_p in
                  let _menhir_stack = MenhirCell0_WS (_menhir_stack, _startpos_3, _endpos_4) in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | MEDIA_FEATURE_COMPARISON _v_5 ->
                      let _tok = _menhir_lexer _menhir_lexbuf in
                      let (_menhir_s, lt) = (MenhirState315, _v_5) in
                      let _v = _menhir_action_060 lt in
                      let _menhir_stack = MenhirCell1_less_than (_menhir_stack, _menhir_s, _v) in
                      (match (_tok : MenhirBasics.token) with
                      | EQUAL_SIGN _v_0 ->
                          _menhir_run_261 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState269
                      | WS ->
                          let _ = _menhir_action_165 () in
                          _menhir_run_270 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
                      | _ ->
                          _eRR ())
                  | _ ->
                      _eRR ())
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_262 : type  ttv_stack ttv_result. (((((ttv_stack, ttv_result) _menhir_cell1_LEFT_PAREN, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_WS as 'stack) -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let mflt = _v in
      let _v = _menhir_action_119 mflt in
      _menhir_goto_mf_comparison _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_151 : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_startpos_c_, c) = (_startpos, _v) in
      let _v = _menhir_action_028 c in
      _menhir_goto_combinator _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_c_ _v _menhir_s _tok
  
  and _menhir_goto_combinator : 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
      | MenhirState119 ->
          _menhir_run_189 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_189 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_156 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_189 : 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_combinator (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState189
      | AMPERSAND | ASTERISK | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_190 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState189 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_190 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_combinator 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState190
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | INTERPOLATION _v_1 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState190
      | IDENT _v_2 ->
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState190
      | HASH _v_3 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState190
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState190
      | _ ->
          _eRR ()
  
  and _menhir_run_156 : 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_combinator (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState156
      | AMPERSAND | ASTERISK | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_157 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState156 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_157 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_combinator 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState157
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | INTERPOLATION _v_1 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState157
      | IDENT _v_2 ->
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState157
      | HASH _v_3 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState157
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState157
      | _ ->
          _eRR ()
  
  and _menhir_run_122 : 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 (_startpos_c_, c) = (_startpos, _v) in
      let _v = _menhir_action_027 c in
      _menhir_goto_combinator _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_c_ _v _menhir_s _tok
  
  and _menhir_goto_skip_ws_right_non_complex_selector_ : 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_left_, left) = (_startpos, _v) in
      let _v = _menhir_action_035 left in
      _menhir_goto_complex_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_left_ _v _menhir_s _tok
  
  and _menhir_goto_complex_selector : 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
      | MenhirState190 ->
          _menhir_run_191 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState075 ->
          _menhir_run_178 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_178 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_178 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_178 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_191 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_ 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_complex_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | COMMA | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_192 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_192 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_complex_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_complex_selector (_menhir_stack, _, xs, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_combinator (_menhir_stack, _menhir_s, c, _startpos_c_) = _menhir_stack in
      let _endpos__4_ = _endpos in
      let _v = _menhir_action_181 c xs in
      _menhir_goto_relative_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__4_ _startpos_c_ _v _menhir_s _tok
  
  and _menhir_goto_relative_selector : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_082 _endpos_x_ _startpos_x_ x in
      let _startpos = _startpos_x_ in
      let _menhir_stack = MenhirCell1_loc_relative_selector_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState182
      | COMMA | RIGHT_PAREN ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_183 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState182 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_183 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_loc_relative_selector_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | COMMA ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _startpos_0, _endpos_1) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState184
          | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | TAG _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_185 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState184 _tok
          | _ ->
              _eRR ())
      | RIGHT_PAREN | WS ->
          let MenhirCell1_loc_relative_selector_ (_menhir_stack, _menhir_s, selector, _startpos_selector_) = _menhir_stack in
          let _endpos__2_ = _endpos in
          let _v = _menhir_action_182 selector in
          _menhir_goto_relative_selector_list _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_selector_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_185 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_loc_relative_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState185
      | MEDIA_FEATURE_COMPARISON _v_1 ->
          _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState185
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | INTERPOLATION _v_2 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState185
      | IDENT _v_3 ->
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState185
      | HASH _v_4 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState185
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | COMBINATOR _v_5 ->
          _menhir_run_122 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState185
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState185
      | _ ->
          _eRR ()
  
  and _menhir_goto_relative_selector_list : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState185 ->
          _menhir_run_187 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_164 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_187 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_loc_relative_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_ 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_relative_selector_list (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState187
      | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_188 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_188 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_loc_relative_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_relative_selector_list -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_relative_selector_list (_menhir_stack, _, seq, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_COMMA (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_relative_selector_ (_menhir_stack, _menhir_s, selector, _startpos_selector_) = _menhir_stack in
      let _endpos__6_ = _endpos in
      let _v = _menhir_action_183 selector seq in
      _menhir_goto_relative_selector_list _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos_selector_ _v _menhir_s _tok
  
  and _menhir_run_164 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_FUNCTION -> _ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _tok ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_083 _endpos_x_ _startpos_x_ x in
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_FUNCTION (_menhir_stack, f, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _menhir_s, _startpos__1_, _) = _menhir_stack in
          let xs = _v in
          let _v = _menhir_action_175 f xs in
          _menhir_goto_pseudo_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_178 : 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_complex_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      let _ = _menhir_action_161 () in
      _menhir_run_179 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
  
  and _menhir_run_179 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_complex_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_complex_selector (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let _endpos__2_ = _endpos in
      let _v = _menhir_action_205 x in
      _menhir_goto_skip_ws_right_complex_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_skip_ws_right_complex_selector_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState185 ->
          _menhir_run_186 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState075 ->
          _menhir_run_172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_172 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_139 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_186 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_loc_relative_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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_180 xs in
      _menhir_goto_relative_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_run_172 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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_187 xs in
      _menhir_goto_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_goto_selector : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_084 _endpos_x_ _startpos_x_ x in
      let _startpos = _startpos_x_ in
      let _menhir_stack = MenhirCell1_loc_selector_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState168
      | COMMA | LEFT_BRACE | RIGHT_PAREN ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_169 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState168 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_169 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_loc_selector_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | COMMA ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_COMMA (_menhir_stack, _startpos_0, _endpos_1) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState170
          | AMPERSAND | ASTERISK | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_171 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState170 _tok
          | _ ->
              _eRR ())
      | LEFT_BRACE | RIGHT_PAREN | WS ->
          let MenhirCell1_loc_selector_ (_menhir_stack, _menhir_s, selector, _startpos_selector_) = _menhir_stack in
          let _endpos__2_ = _endpos in
          let _v = _menhir_action_188 selector in
          _menhir_goto_selector_list _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_selector_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_171 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_loc_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | TAG _v_0 ->
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState171
      | LEFT_BRACKET ->
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | INTERPOLATION _v_1 ->
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState171
      | IDENT _v_2 ->
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState171
      | HASH _v_3 ->
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState171
      | DOUBLE_COLON ->
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | DOT ->
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | COLON ->
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | ASTERISK ->
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | AMPERSAND ->
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState171
      | _ ->
          _eRR ()
  
  and _menhir_goto_selector_list : 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
      | MenhirState171 ->
          _menhir_run_173 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState075 ->
          _menhir_run_162 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_162 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_173 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_loc_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_ 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_selector_list (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState173
      | LEFT_BRACE | RIGHT_PAREN ->
          let _ = _menhir_action_161 () in
          _menhir_run_174 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_174 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_loc_selector_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_COMMA, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_selector_list -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_selector_list (_menhir_stack, _, seq, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell0_COMMA (_menhir_stack, _, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_selector_ (_menhir_stack, _menhir_s, selector, _startpos_selector_) = _menhir_stack in
      let _endpos__6_ = _endpos in
      let _v = _menhir_action_189 selector seq in
      _menhir_goto_selector_list _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__6_ _startpos_selector_ _v _menhir_s _tok
  
  and _menhir_run_162 : 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_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_085 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_selector_list_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_loc_selector_list_ : 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
      | MenhirState075 ->
          _menhir_run_199 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_166 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_199 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ 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_loc_selector_list_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState199
      | LEFT_BRACE ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_200 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState199 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_200 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_selector_list_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          _menhir_run_201 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState200
      | _ ->
          _eRR ()
  
  and _menhir_run_166 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_FUNCTION -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      match (_tok : MenhirBasics.token) with
      | RIGHT_PAREN ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_FUNCTION (_menhir_stack, f, _, _) = _menhir_stack in
          let MenhirCell1_COLON (_menhir_stack, _menhir_s, _startpos__1_, _) = _menhir_stack in
          let xs = _v in
          let _v = _menhir_action_176 f xs in
          _menhir_goto_pseudo_class_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_139 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_FUNCTION as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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_187 xs in
      _menhir_goto_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_xs_ _v _menhir_s _tok
  
  and _menhir_run_160 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_ 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_compound_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState160
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_161 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_161 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_compound_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_compound_selector (_menhir_stack, _, s, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_combinator (_menhir_stack, _menhir_s, c, _) = _menhir_stack in
      let _v = _menhir_action_034 c s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_goto_combinator_sequence : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_142 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | TAG _v_0 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState154
      | MEDIA_FEATURE_COMPARISON _v_1 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState154
      | LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | INTERPOLATION _v_2 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState154
      | IDENT _v_3 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState154
      | HASH _v_4 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState154
      | DOUBLE_COLON ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | DOT ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | COMBINATOR _v_5 ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_122 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState154
      | COLON ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | ASTERISK ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | AMPERSAND ->
          let _menhir_stack = MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, _v) in
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState154
      | COMMA | LEFT_BRACE | RIGHT_PAREN ->
          let x = _v in
          let _v = _menhir_action_131 x in
          _menhir_goto_nonempty_list_combinator_sequence_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_combinator_sequence_ : type  ttv_stack ttv_result. ttv_stack -> _ -> _ -> _ -> _ -> (ttv_stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState176 ->
          _menhir_run_177 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState154 ->
          _menhir_run_155 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState141 ->
          _menhir_run_150 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_177 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_compound_selector, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_compound_selector (_menhir_stack, _menhir_s, s, _startpos_s_) = _menhir_stack in
      let seq = _v in
      let _v = _menhir_action_037 s seq in
      _menhir_goto_complex_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_155 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_combinator_sequence -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_combinator_sequence (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_132 x xs in
      _menhir_goto_nonempty_list_combinator_sequence_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_150 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_simple_selector, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_simple_selector (_menhir_stack, _menhir_s, s, _startpos_s_) = _menhir_stack in
      let seq = _v in
      let _v = _menhir_action_036 s seq in
      _menhir_goto_complex_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_s_ _v _menhir_s _tok
  
  and _menhir_run_152 : 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_compound_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState152
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_153 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_153 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_compound_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_compound_selector (_menhir_stack, _menhir_s, s, _) = _menhir_stack in
      let _v = _menhir_action_032 s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_147 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_WS -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_WS (_menhir_stack, _menhir_s, _, _) = _menhir_stack in
      let s = _v in
      let _v = _menhir_action_030 s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_144 : 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_ps_, ps) = (_startpos, _v) in
      let _v = _menhir_action_042 ps in
      _menhir_goto_compound_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_ps_ _v _menhir_s _tok
  
  and _menhir_run_132 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_type_selector -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_type_selector (_menhir_stack, _menhir_s, t, _startpos_t_) = _menhir_stack in
      let ps = _v in
      let _v = _menhir_action_041 ps t in
      _menhir_goto_compound_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_t_ _v _menhir_s _tok
  
  and _menhir_run_127 : 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_pcs_, pcs) = (_startpos, _v) in
      let _v = _menhir_action_215 pcs in
      _menhir_goto_subclass_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_pcs_ _v _menhir_s _tok
  
  and _menhir_run_107 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_NTH_FUNCTION _menhir_cell0_IDENT -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      match (_tok : MenhirBasics.token) with
      | COMBINATOR _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NUMBER _v_3 ->
              let _endpos_5 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell0_IDENT (_menhir_stack, n, _startpos_n_, _) = _menhir_stack in
              let (_endpos_b_, b, combinator) = (_endpos_5, _v_3, _v_0) in
              let _v = _menhir_action_155 b combinator n in
              _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_n_ _v _tok
          | _ ->
              _eRR ())
      | RIGHT_PAREN ->
          let MenhirCell0_IDENT (_menhir_stack, n, _startpos_n_, _) = _menhir_stack in
          let _endpos__2_ = _endpos in
          let _v = _menhir_action_154 n in
          _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__2_ _startpos_n_ _v _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_111 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_COLON _menhir_cell0_NTH_FUNCTION _menhir_cell0_DIMENSION -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _tok ->
      match (_tok : MenhirBasics.token) with
      | NUMBER _v_0 ->
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell0_DIMENSION (_menhir_stack, a, _startpos_a_, _) = _menhir_stack in
          let (_endpos_b_, b) = (_endpos_2, _v_0) in
          let _v = _menhir_action_153 a b in
          _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_a_ _v _tok
      | COMBINATOR _v_3 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | NUMBER _v_6 ->
              let _endpos_8 = _menhir_lexbuf.Lexing.lex_curr_p in
              let _tok = _menhir_lexer _menhir_lexbuf in
              let MenhirCell0_DIMENSION (_menhir_stack, a, _startpos_a_, _) = _menhir_stack in
              let (_endpos_b_, b, combinator) = (_endpos_8, _v_6, _v_3) in
              let _v = _menhir_action_152 a b combinator in
              _menhir_goto_nth_payload _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_b_ _startpos_a_ _v _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_subclass_selector_ : 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
      | MenhirState075 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState190 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState157 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState142 ->
          _menhir_run_145 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState125 ->
          _menhir_run_137 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState126 ->
          _menhir_run_128 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_145 : 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
      | DOUBLE_COLON ->
          let _menhir_stack = MenhirCell1_nonempty_list_subclass_selector_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState145
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ | WS ->
          let (_startpos_sub_, sub) = (_startpos, _v) in
          let _v = _menhir_action_040 sub in
          _menhir_goto_compound_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_sub_ _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_137 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_type_selector -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_type_selector (_menhir_stack, _menhir_s, t, _startpos_t_) = _menhir_stack in
      let sub = _v in
      let _v = _menhir_action_039 sub t in
      _menhir_goto_compound_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_t_ _v _menhir_s _tok
  
  and _menhir_run_128 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_subclass_selector -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_subclass_selector (_menhir_stack, _menhir_s, x, _startpos_x_) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_146 x xs in
      _menhir_goto_nonempty_list_subclass_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s _tok
  
  and _menhir_goto_attr_matcher : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let _menhir_stack = MenhirCell0_attr_matcher (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState086
      | IDENT _ | STRING _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_087 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState086 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_087 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | STRING _v_0 ->
          let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_STRING (_menhir_stack, _v_0, _startpos_1, _endpos_2) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState088
          | RIGHT_BRACKET ->
              let _ = _menhir_action_161 () in
              _menhir_run_089 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
          | _ ->
              _eRR ())
      | IDENT _v_4 ->
          let _startpos_5 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_6 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_4, _startpos_5, _endpos_6) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState091
          | RIGHT_BRACKET ->
              let _ = _menhir_action_161 () in
              _menhir_run_092 _menhir_stack _menhir_lexbuf _menhir_lexer _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_089 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_STRING -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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 MenhirCell0_STRING (_menhir_stack, v, _, _) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell0_attr_matcher (_menhir_stack, m) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell0_wq_name (_menhir_stack, i) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos = _endpos_0 in
          let _v = _menhir_action_016 i m v in
          _menhir_goto_attribute_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_092 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_LEFT_BRACKET, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_wq_name, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_attr_matcher, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_IDENT -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _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 MenhirCell0_IDENT (_menhir_stack, v, _, _) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell0_attr_matcher (_menhir_stack, m) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell0_wq_name (_menhir_stack, i) = _menhir_stack in
          let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
          let MenhirCell1_LEFT_BRACKET (_menhir_stack, _menhir_s, _startpos__1_) = _menhir_stack in
          let _endpos = _endpos_0 in
          let _v = _menhir_action_017 i m v in
          _menhir_goto_attribute_selector _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos__1_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_simple_selector : 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
      | MenhirState157 ->
          _menhir_run_158 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState176 ->
          _menhir_run_148 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState154 ->
          _menhir_run_148 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState141 ->
          _menhir_run_148 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState142 ->
          _menhir_run_143 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState075 ->
          _menhir_run_140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState190 ->
          _menhir_run_140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState185 ->
          _menhir_run_140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState171 ->
          _menhir_run_140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState119 ->
          _menhir_run_140 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_158 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_ 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_simple_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState158
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_159 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_159 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_combinator, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_simple_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_simple_selector (_menhir_stack, _, s, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_combinator (_menhir_stack, _menhir_s, c, _) = _menhir_stack in
      let _v = _menhir_action_033 c s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_148 : 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_simple_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState148
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_149 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_149 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_simple_selector -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_simple_selector (_menhir_stack, _menhir_s, s, _) = _menhir_stack in
      let _v = _menhir_action_031 s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_143 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_WS -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_WS (_menhir_stack, _menhir_s, _, _) = _menhir_stack in
      let s = _v in
      let _v = _menhir_action_029 s in
      _menhir_goto_combinator_sequence _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_140 : 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_simple_selector (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState140
      | AMPERSAND | ASTERISK | COLON | COMBINATOR _ | COMMA | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACE | LEFT_BRACKET | MEDIA_FEATURE_COMPARISON _ | RIGHT_PAREN | TAG _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_141 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState140 _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_141 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_simple_selector as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | WS ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_142 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | TAG _v_0 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_076 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState141
      | MEDIA_FEATURE_COMPARISON _v_1 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_120 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState141
      | LEFT_BRACKET ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_077 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | INTERPOLATION _v_2 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_094 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState141
      | IDENT _v_3 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_121 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState141
      | HASH _v_4 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_096 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState141
      | DOUBLE_COLON ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_097 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | DOT ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_099 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | COMBINATOR _v_5 ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_122 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState141
      | COLON ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_103 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | ASTERISK ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_123 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | AMPERSAND ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_124 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState141
      | COMMA | LEFT_BRACE | RIGHT_PAREN ->
          let MenhirCell1_simple_selector (_menhir_stack, _menhir_s, s, _startpos_s_) = _menhir_stack in
          let _v = _menhir_action_206 s in
          _menhir_goto_skip_ws_right_non_complex_selector_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_s_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_loc_IDENT_ : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ 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_loc_IDENT_ (_menhir_stack, _menhir_s, _v, _startpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState007
      | COLON ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_008 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState007 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_008 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) 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
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState009
          | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
              let _v_2 = _menhir_action_161 () in
              _menhir_run_010 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_2 MenhirState009 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_010 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_IDENT_, ttv_result) _menhir_cell1_option_WS_ _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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState010
      | ALL_MEDIA_TYPE _ | ASTERISK | COLON | COMBINATOR _ | COMMA | DELIM _ | DIMENSION _ | DOT | DOUBLE_COLON | FLOAT_DIMENSION _ | FUNCTION _ | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | LEFT_PAREN | MEDIA_QUERY_OPERATOR _ | NUMBER _ | OPERATOR _ | SCREEN_MEDIA_TYPE _ | STRING _ | TAG _ | UNICODE_RANGE _ | URL _ ->
          let _v_0 = _menhir_action_161 () in
          _menhir_run_013 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState010 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_224 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_STATEMENT_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | URL _v_0 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState224
      | UNICODE_RANGE _v_1 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState224
      | TAG _v_2 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState224
      | STRING _v_3 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState224
      | SCREEN_MEDIA_TYPE _v_4 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState224
      | OPERATOR _v_5 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState224
      | NUMBER _v_6 ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState224
      | MEDIA_QUERY_OPERATOR _v_7 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState224
      | LEFT_PAREN ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | LEFT_BRACKET ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | INTERPOLATION _v_8 ->
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState224
      | IDENT _v_9 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState224
      | HASH _v_10 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState224
      | FUNCTION _v_11 ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState224
      | FLOAT_DIMENSION _v_12 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState224
      | DOUBLE_COLON ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | DOT ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | DIMENSION _v_13 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState224
      | DELIM _v_14 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 MenhirState224
      | COMMA ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | COMBINATOR _v_15 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 MenhirState224
      | COLON ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | ASTERISK ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState224
      | ALL_MEDIA_TYPE _v_16 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 MenhirState224
      | _ ->
          _eRR ()
  
  and _menhir_run_231 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_RULE_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | URL _v_0 ->
          _menhir_run_014 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState231
      | UNICODE_RANGE _v_1 ->
          _menhir_run_015 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState231
      | TAG _v_2 ->
          _menhir_run_016 _menhir_stack _menhir_lexbuf _menhir_lexer _v_2 MenhirState231
      | STRING _v_3 ->
          _menhir_run_017 _menhir_stack _menhir_lexbuf _menhir_lexer _v_3 MenhirState231
      | SCREEN_MEDIA_TYPE _v_4 ->
          _menhir_run_018 _menhir_stack _menhir_lexbuf _menhir_lexer _v_4 MenhirState231
      | OPERATOR _v_5 ->
          _menhir_run_019 _menhir_stack _menhir_lexbuf _menhir_lexer _v_5 MenhirState231
      | NUMBER _v_6 ->
          _menhir_run_020 _menhir_stack _menhir_lexbuf _menhir_lexer _v_6 MenhirState231
      | MEDIA_QUERY_OPERATOR _v_7 ->
          _menhir_run_022 _menhir_stack _menhir_lexbuf _menhir_lexer _v_7 MenhirState231
      | LEFT_PAREN ->
          _menhir_run_023 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | LEFT_BRACKET ->
          _menhir_run_029 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | INTERPOLATION _v_8 ->
          _menhir_run_032 _menhir_stack _menhir_lexbuf _menhir_lexer _v_8 MenhirState231
      | IDENT _v_9 ->
          _menhir_run_033 _menhir_stack _menhir_lexbuf _menhir_lexer _v_9 MenhirState231
      | HASH _v_10 ->
          _menhir_run_034 _menhir_stack _menhir_lexbuf _menhir_lexer _v_10 MenhirState231
      | FUNCTION _v_11 ->
          _menhir_run_035 _menhir_stack _menhir_lexbuf _menhir_lexer _v_11 MenhirState231
      | FLOAT_DIMENSION _v_12 ->
          _menhir_run_036 _menhir_stack _menhir_lexbuf _menhir_lexer _v_12 MenhirState231
      | DOUBLE_COLON ->
          _menhir_run_037 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | DOT ->
          _menhir_run_038 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | DIMENSION _v_13 ->
          _menhir_run_039 _menhir_stack _menhir_lexbuf _menhir_lexer _v_13 MenhirState231
      | DELIM _v_14 ->
          _menhir_run_040 _menhir_stack _menhir_lexbuf _menhir_lexer _v_14 MenhirState231
      | COMMA ->
          _menhir_run_041 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | COMBINATOR _v_15 ->
          _menhir_run_042 _menhir_stack _menhir_lexbuf _menhir_lexer _v_15 MenhirState231
      | COLON ->
          _menhir_run_043 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | ASTERISK ->
          _menhir_run_044 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState231
      | ALL_MEDIA_TYPE _v_16 ->
          _menhir_run_045 _menhir_stack _menhir_lexbuf _menhir_lexer _v_16 MenhirState231
      | _ ->
          _eRR ()
  
  and _menhir_run_249 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState249
      | MEDIA_QUERY_OPERATOR _v_0 ->
          _menhir_run_250 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState249
      | LEFT_PAREN ->
          _menhir_run_251 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState249
      | INTERPOLATION _v_1 ->
          let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v_4 =
            let v = _v_1 in
            _menhir_action_053 v
          in
          _menhir_run_291 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_3 _startpos_2 _v_4 MenhirState249 _tok
      | ALL_MEDIA_TYPE _ | PRINT_MEDIA_TYPE _ | SCREEN_MEDIA_TYPE _ ->
          let _menhir_s = MenhirState249 in
          let _v = _menhir_action_167 () in
          _menhir_goto_option_not_or_only_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_386 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_KEYFRAMES_ 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | IDENT _v_0 ->
          let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_IDENT (_menhir_stack, _v_0, _startpos_1, _endpos_2) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState387
          | LEFT_BRACE ->
              let _v_3 = _menhir_action_161 () in
              _menhir_run_388 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_2 _endpos_2 _v_3 MenhirState387 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_388 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_KEYFRAMES_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_IDENT 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          let _startpos_0 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_1 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell1_LEFT_BRACE (_menhir_stack, MenhirState388, _startpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState389
          | RIGHT_BRACE ->
              _menhir_run_202 _menhir_stack _menhir_lexbuf _menhir_lexer
          | LEFT_BRACE ->
              let (_endpos, _menhir_s) = (_endpos_1, MenhirState389) in
              let _v = _menhir_action_088 () in
              _menhir_goto_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v _menhir_s
          | IDENT _ | NUMBER _ ->
              let _v_3 = _menhir_action_161 () in
              _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_1 _endpos_1 _v_3 MenhirState389 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_398 : 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | NUMBER _v_0 ->
          _menhir_run_394 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState398
      | IDENT _v_1 ->
          let _startpos_2 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_3 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell1_IDENT (_menhir_stack, MenhirState398, _v_1, _startpos_2, _endpos_3) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState399
          | LEFT_BRACE ->
              let _v_4 = _menhir_action_161 () in
              _menhir_run_400 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_3 _endpos_3 _v_4 MenhirState399 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_400 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT 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_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | LEFT_BRACE ->
          _menhir_run_401 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState400
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_keyframe_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 ->
      match _menhir_s with
      | MenhirState412 ->
          _menhir_run_413 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok
      | MenhirState428 ->
          _menhir_run_408 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState429 ->
          _menhir_run_408 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState389 ->
          _menhir_run_408 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_413 : type  ttv_stack ttv_result. (ttv_stack, ttv_result) _menhir_cell1_keyframe_style_rule -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_keyframe_style_rule (_menhir_stack, _menhir_s, x, _startpos_x_, _) = _menhir_stack in
      let (_endpos_xs_, xs) = (_endpos, _v) in
      let _v = _menhir_action_134 x xs in
      _menhir_goto_nonempty_list_keyframe_style_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_xs_ _startpos_x_ _v _menhir_s _tok
  
  and _menhir_run_408 : 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_rules_, _startpos_rules_, rules) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_054 rules in
      _menhir_goto_keyframe _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_rules_ _startpos_rules_ _v _menhir_s _tok
  
  and _menhir_goto_keyframe : 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
      | MenhirState428 ->
          _menhir_run_433 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState429 ->
          _menhir_run_433 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | MenhirState389 ->
          _menhir_run_414 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_433 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_keyframes) _menhir_state -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let (_endpos_x_, _startpos_x_, x) = (_endpos, _startpos, _v) in
      let _v = _menhir_action_076 _endpos_x_ _startpos_x_ x in
      _menhir_goto_loc_keyframe_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_loc_keyframe_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_keyframes) _menhir_state -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState428 ->
          _menhir_run_434 _menhir_stack _v _tok
      | MenhirState429 ->
          _menhir_run_430 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_430 : type  ttv_stack. ((ttv_stack, _menhir_box_keyframes) _menhir_cell1_LEFT_BRACE as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_keyframes) _menhir_state -> _ -> _menhir_box_keyframes =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_loc_keyframe_ (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_RIGHT_BRACE (_menhir_stack, _endpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEMI_COLON ->
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState431
          | EOF ->
              let _ = _menhir_action_159 () in
              _menhir_run_432 _menhir_stack _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_414 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_KEYFRAMES_, ttv_result) _menhir_cell1_option_WS_ _menhir_cell0_IDENT, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_LEFT_BRACE 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_keyframe (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | RIGHT_BRACE ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell0_RIGHT_BRACE (_menhir_stack, _endpos_0) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | SEMI_COLON ->
              _menhir_run_059 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState415
          | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | TAG _ | WS ->
              let _ = _menhir_action_159 () in
              _menhir_run_416 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos_0 _tok
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_406 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_percentage, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState406
      | EOF | IDENT _ | LEFT_BRACE | NUMBER _ | RIGHT_BRACE ->
          let _ = _menhir_action_161 () in
          _menhir_run_407 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_407 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_percentage, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_brace_block_loc_declarations__ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _, declarations, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_percentage (_menhir_stack, _, p, _startpos_p_, _endpos_p_) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_056 _endpos__5_ _endpos_p_ _startpos__1_ _startpos_p_ declarations p in
      _menhir_goto_keyframe_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_402 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState402
      | EOF | IDENT _ | LEFT_BRACE | NUMBER _ | RIGHT_BRACE ->
          let _ = _menhir_action_161 () in
          _menhir_run_403 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_403 : type  ttv_stack ttv_result. ((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_IDENT, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_brace_block_loc_declarations__ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _, declarations, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_IDENT (_menhir_stack, _, id, _startpos_id_, _endpos_id_) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _, _startpos__1_, _) = _menhir_stack in
      let _endpos__5_ = _endpos in
      let _v = _menhir_action_055 _endpos__5_ _endpos_id_ _startpos__1_ _startpos_id_ declarations id in
      _menhir_goto_keyframe_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos__5_ _startpos__1_ _v _menhir_s _tok
  
  and _menhir_run_381 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_media_query_prelude_, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> ('stack, ttv_result) _menhir_state -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _menhir_s, _v, _endpos) in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState381
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | RIGHT_BRACE | SEMI_COLON | TAG _ ->
          let _ = _menhir_action_161 () in
          _menhir_run_382 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_382 : type  ttv_stack ttv_result. ((((((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_AT_MEDIA_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_media_query_prelude_, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_brace_block_loc_declarations__ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _tok ->
      let MenhirCell1_brace_block_loc_declarations__ (_menhir_stack, _, ds, _) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_media_query_prelude_ (_menhir_stack, _, prelude) = _menhir_stack in
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_AT_MEDIA_ (_menhir_stack, _menhir_s, name, _startpos_name_) = _menhir_stack in
      let _endpos__6_ = _endpos in
      let _v = _menhir_action_007 _endpos__6_ _startpos_name_ ds name prelude in
      _menhir_goto_at_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_222 : type  ttv_stack ttv_result. (((ttv_stack, ttv_result) _menhir_cell1_option_WS_, ttv_result) _menhir_cell1_loc_selector_list_, ttv_result) _menhir_cell1_option_WS_ -> _ -> _ -> _ -> _ -> _ -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _tok ->
      let MenhirCell1_option_WS_ (_menhir_stack, _, _, _, _) = _menhir_stack in
      let MenhirCell1_loc_selector_list_ (_menhir_stack, _menhir_s, prelude, _startpos_prelude_) = _menhir_stack in
      let (_endpos_declarations_, declarations) = (_endpos, _v) in
      let _v = _menhir_action_209 _endpos_declarations_ _startpos_prelude_ declarations prelude in
      _menhir_goto_style_rule _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
  
  and _menhir_run_211 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_option_WS_ as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState211
      | SEMI_COLON ->
          let _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState211
      | EOF | RIGHT_BRACE ->
          let r = _v in
          let _v = _menhir_action_140 r in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState211 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_073 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_skip_ws_at_rule_ as 'stack) -> _ -> _ -> ('stack, ttv_result) _menhir_state -> ttv_result =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
      let _menhir_stack = MenhirCell1_SEMI_COLON (_menhir_stack, _menhir_s, _endpos) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState073
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState073 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_207 : 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
      | WS ->
          let _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState207
      | EOF | RIGHT_BRACE | SEMI_COLON ->
          let r = _v in
          let _v = _menhir_action_140 r in
          _menhir_goto_nonempty_list_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          let _v_0 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_0 MenhirState207 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_072 : type  ttv_stack ttv_result. ((ttv_stack, ttv_result) _menhir_cell1_SEMI_COLON as 'stack) -> _ -> _ -> _ -> _ -> _ -> ('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 _menhir_stack = MenhirCell1_skip_ws_at_rule_ (_menhir_stack, _menhir_s, _v, _startpos) in
          _menhir_run_073 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState072
      | EOF | RIGHT_BRACE ->
          let r = _v in
          let _v = _menhir_action_193 r in
          _menhir_goto_separated_nonempty_list_SEMI_COLON_rule_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_065 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_declaration_list) _menhir_state -> _ -> _menhir_box_declaration_list =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | WS ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState065
      | EOF ->
          let _endpos_0 = _menhir_lexbuf.Lexing.lex_curr_p in
          let (_startpos__1_, _endpos__2_) = (_startpos, _endpos_0) in
          let _v = _menhir_action_044 _endpos__2_ _startpos__1_ in
          _menhir_goto_declaration_list _menhir_stack _v
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
          let _v_1 = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v_1 MenhirState065 _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_005 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _ -> (ttv_stack, _menhir_box_declaration) _menhir_state -> _ -> _menhir_box_declaration =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_option_WS_ (_menhir_stack, _menhir_s, _v, _startpos, _endpos) in
      match (_tok : MenhirBasics.token) with
      | IDENT _v_0 ->
          let _startpos_1 = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos_2 = _menhir_lexbuf.Lexing.lex_curr_p in
          let _tok = _menhir_lexer _menhir_lexbuf in
          let (_endpos, _menhir_s, _endpos_x_, _startpos_x_, x) = (_endpos_2, MenhirState005, _endpos_2, _startpos_1, _v_0) in
          let _v = _menhir_action_072 _endpos_x_ _startpos_x_ x in
          _menhir_goto_loc_IDENT_ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _startpos_x_ _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_000 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_declaration =
    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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState000
      | IDENT _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_005 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState000 _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_064 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_declaration_list =
    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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState064
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | EOF | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_065 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState064 _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_428 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_keyframes =
    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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState428
      | LEFT_BRACE ->
          let _startpos = _menhir_lexbuf.Lexing.lex_start_p in
          let _endpos = _menhir_lexbuf.Lexing.lex_curr_p in
          let _menhir_stack = MenhirCell1_LEFT_BRACE (_menhir_stack, MenhirState428, _startpos) in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | WS ->
              _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState429
          | LEFT_BRACE ->
              let _menhir_s = MenhirState429 in
              let _v = _menhir_action_088 () in
              _menhir_goto_loption_separated_nonempty_list_COMMA_skip_ws_percentage___ _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v _menhir_s
          | IDENT _ | NUMBER _ ->
              let _v = _menhir_action_161 () in
              _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState429 _tok
          | _ ->
              _eRR ())
      | IDENT _ | NUMBER _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_398 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState428 _tok
      | _ ->
          _eRR ()
  
  let _menhir_run_439 : 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
      | WS ->
          _menhir_run_001 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState439
      | EOF ->
          let _v = _menhir_action_063 () in
          _menhir_run_245 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState439 _tok
      | AMPERSAND | ASTERISK | AT_KEYFRAMES _ | AT_MEDIA _ | AT_RULE _ | AT_RULE_STATEMENT _ | COLON | DOT | DOUBLE_COLON | HASH _ | IDENT _ | INTERPOLATION _ | LEFT_BRACKET | TAG _ ->
          let _v = _menhir_action_161 () in
          _menhir_run_075 _menhir_stack _menhir_lexbuf _menhir_lexer _endpos _endpos _v MenhirState439 _tok
      | _ ->
          _eRR ()
  
end

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

let keyframes =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_keyframes v = _menhir_run_428 _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_064 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v

let declaration =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_declaration v = _menhir_run_000 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v