Initial commit to copy sourcecode from servo/rust-cssparser Change-Id: I8c584043ce30278417a5d4d262b8e3d6ebd6fb03
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml new file mode 100644 index 0000000..a7be6ae --- /dev/null +++ b/.github/workflows/main.yml
@@ -0,0 +1,82 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + merge_group: + types: [checks_requested] + +jobs: + linux-ci: + name: Linux + runs-on: ubuntu-latest + strategy: + matrix: + toolchain: + - nightly + - beta + - stable + - 1.63.0 + features: + - + - --features dummy_match_byte + - --features malloc_size_of + include: + - toolchain: nightly + features: --features bench + - toolchain: nightly + features: --features bench,dummy_match_byte + steps: + - uses: actions/checkout@v2 + + - name: Install toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: ${{ matrix.toolchain }} + override: true + components: rustfmt, clippy, ${{ matrix.toolchain == 'nightly' && 'miri,rust-src' || '' }} + + - name: Cargo format & lint + run: cargo fmt --check && cargo clippy -- -Dwarnings + + - name: Cargo build + run: cargo build ${{ matrix.features }} + + - name: Cargo doc + run: cargo doc ${{ matrix.features }} + + - name: Cargo test + run: cargo test ${{ matrix.features }} + + - name: macros build + run: cargo build + working-directory: macros + + - name: Color build + run: cargo build + working-directory: color + + - name: Color test + run: cargo test + working-directory: color + + - name: Cargo miri test + if: "matrix.toolchain == 'nightly'" + run: cargo miri test --features skip_long_tests ${{ matrix.features }} + + build_result: + name: Result + runs-on: ubuntu-latest + needs: + - "linux-ci" + + steps: + - name: Mark the job as successful + run: exit 0 + if: success() + - name: Mark the job as unsuccessful + run: exit 1 + if: "!success()"
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0b837ea --- /dev/null +++ b/.gitignore
@@ -0,0 +1,3 @@ +target +/Cargo.lock +/.cargo/config
diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..f4e980f --- /dev/null +++ b/Cargo.toml
@@ -0,0 +1,42 @@ +[package] +name = "cssparser" +version = "0.34.1" +authors = ["Simon Sapin <simon.sapin@exyr.org>"] + +description = "Rust implementation of CSS Syntax Level 3" +documentation = "https://docs.rs/cssparser/" +repository = "https://github.com/servo/rust-cssparser" +readme = "README.md" +keywords = ["css", "syntax", "parser"] +license = "MPL-2.0" +edition = "2018" +rust-version = "1.63" + +exclude = ["src/css-parsing-tests/**", "src/big-data-url.css"] + +[dev-dependencies] +serde_json = "1.0.25" +difference = "2.0" +encoding_rs = "0.8" + +[dependencies] +cssparser-macros = { path = "./macros", version = "0.6.1" } +dtoa-short = "0.3" +itoa = "1.0" +phf = { version = "0.11.2", features = ["macros"] } +serde = { version = "1.0", features = ["derive"], optional = true } +malloc_size_of = { version = "0.1", default-features = false, optional = true } +smallvec = "1.0" + +[profile.profiling] +inherits = "release" +debug = true + +[features] +bench = [] +dummy_match_byte = [] +# Useful for skipping tests when execution is slow, e.g., under miri +skip_long_tests = [] + +[workspace] +members = [".", "./macros", "./color"]
diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..14e2f77 --- /dev/null +++ b/LICENSE
@@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0.
diff --git a/README.md b/README.md new file mode 100644 index 0000000..d9ca4ad --- /dev/null +++ b/README.md
@@ -0,0 +1,57 @@ +rust-cssparser +============== + +[](https://github.com/servo/rust-cssparser/actions) + +[Documentation](https://docs.rs/cssparser) + +Rust implementation of +[CSS Syntax Module Level 3](https://drafts.csswg.org/css-syntax/) + + +Overview +-------- + +Parsing CSS involves a series of steps: + +* When parsing from bytes, + (e.g. reading a file or fetching an URL from the network,) + detect the character encoding + (based on a `Content-Type` HTTP header, an `@charset` rule, a BOM, etc.) + and decode to Unicode text. + + rust-cssparser does not do this yet and just assumes UTF-8. + + This step is skipped when parsing from Unicode, e.g. in an HTML `<style>` element. + +* Tokenization, a.k.a. lexing. + The input, a stream of Unicode text, is transformed into a stream of *tokens*. + Tokenization never fails, although the output may contain *error tokens*. + +* This flat stream of tokens is then transformed into a tree of *component values*, + which are either *preserved tokens*, + or blocks/functions (`{ … }`, `[ … ]`, `( … )`, `foo( … )`) + that contain more component values. + + rust-cssparser does this at the same time as tokenization: + raw tokens are never materialized, you only get component values. + +* Component values can then be parsed into generic rules or declarations. + The header and body of rules as well as the value of declarations + are still just lists of component values at this point. + See [the `Token` enum](src/tokenizer.rs) for the data structure. + +* The last step of a full CSS parser is + parsing the remaining component values + into [Selectors](https://drafts.csswg.org/selectors/), + specific CSS properties, etc. + + By design, rust-cssparser does not do this last step + which depends a lot on what you want to do: + which properties you want to support, what you want to do with selectors, etc. + + It does however provide some helper functions to parse [CSS colors](src/color.rs) + and [An+B](src/nth.rs) (the argument to `:nth-child()` and related selectors. + + See [Servo’s `style` crate](https://github.com/servo/stylo/tree/main/style) + for an example of a parser based on rust-cssparser.
diff --git a/color/Cargo.toml b/color/Cargo.toml new file mode 100644 index 0000000..d5cde91 --- /dev/null +++ b/color/Cargo.toml
@@ -0,0 +1,24 @@ +[package] +name = "cssparser-color" +version = "0.2.0" +authors = ["Emilio Cobos Álvarez <emilio@crisal.io>"] +description = "Color implementation based on cssparser" +documentation = "https://docs.rs/cssparser-color/" +repository = "https://github.com/servo/rust-cssparser" +license = "MPL-2.0" +edition = "2021" + +[lib] +path = "lib.rs" + +[dependencies] +cssparser = { path = "..", version = "0.34" } +serde = { version = "1.0", features = ["derive"], optional = true } + +[features] +serde = ["cssparser/serde", "dep:serde"] + +[dev-dependencies] +serde_json = "1.0.25" +difference = "2.0" +encoding_rs = "0.8"
diff --git a/color/lib.rs b/color/lib.rs new file mode 100644 index 0000000..5b116c2 --- /dev/null +++ b/color/lib.rs
@@ -0,0 +1,1199 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#![deny(missing_docs)] + +//! Fairly complete css-color implementation. +//! Relative colors, color-mix, system colors, and other such things require better calc() support +//! and integration. + +#[cfg(test)] +mod tests; + +use cssparser::color::{ + clamp_floor_256_f32, clamp_unit_f32, parse_hash_color, serialize_color_alpha, + PredefinedColorSpace, OPAQUE, +}; +use cssparser::{match_ignore_ascii_case, CowRcStr, ParseError, Parser, ToCss, Token}; +use std::f32::consts::PI; +use std::fmt; + +/// Return the named color with the given name. +/// +/// Matching is case-insensitive in the ASCII range. +/// CSS escaping (if relevant) should be resolved before calling this function. +/// (For example, the value of an `Ident` token is fine.) +#[allow(clippy::result_unit_err)] +#[inline] +pub fn parse_color_keyword<Output>(ident: &str) -> Result<Output, ()> +where + Output: FromParsedColor, +{ + Ok(match_ignore_ascii_case! { ident , + "transparent" => Output::from_rgba(0, 0, 0, 0.0), + "currentcolor" => Output::from_current_color(), + _ => { + let (r, g, b) = cssparser::color::parse_named_color(ident)?; + Output::from_rgba(r, g, b, OPAQUE) + } + }) +} + +/// Parse a CSS color using the specified [`ColorParser`] and return a new color +/// value on success. +pub fn parse_color_with<'i, 't, P>( + color_parser: &P, + input: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let location = input.current_source_location(); + let token = input.next()?; + match *token { + Token::Hash(ref value) | Token::IDHash(ref value) => { + parse_hash_color(value.as_bytes()).map(|(r, g, b, a)| P::Output::from_rgba(r, g, b, a)) + } + Token::Ident(ref value) => parse_color_keyword(value), + Token::Function(ref name) => { + let name = name.clone(); + return input.parse_nested_block(|arguments| { + parse_color_function(color_parser, name, arguments) + }); + } + _ => Err(()), + } + .map_err(|()| location.new_unexpected_token_error(token.clone())) +} + +/// Parse one of the color functions: rgba(), lab(), color(), etc. +#[inline] +fn parse_color_function<'i, 't, P>( + color_parser: &P, + name: CowRcStr<'i>, + arguments: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let color = match_ignore_ascii_case! { &name, + "rgb" | "rgba" => parse_rgb(color_parser, arguments), + + "hsl" | "hsla" => parse_hsl(color_parser, arguments), + + "hwb" => parse_hwb(color_parser, arguments), + + // for L: 0% = 0.0, 100% = 100.0 + // for a and b: -100% = -125, 100% = 125 + "lab" => parse_lab_like(color_parser, arguments, 100.0, 125.0, P::Output::from_lab), + + // for L: 0% = 0.0, 100% = 100.0 + // for C: 0% = 0, 100% = 150 + "lch" => parse_lch_like(color_parser, arguments, 100.0, 150.0, P::Output::from_lch), + + // for L: 0% = 0.0, 100% = 1.0 + // for a and b: -100% = -0.4, 100% = 0.4 + "oklab" => parse_lab_like(color_parser, arguments, 1.0, 0.4, P::Output::from_oklab), + + // for L: 0% = 0.0, 100% = 1.0 + // for C: 0% = 0.0 100% = 0.4 + "oklch" => parse_lch_like(color_parser, arguments, 1.0, 0.4, P::Output::from_oklch), + + "color" => parse_color_with_color_space(color_parser, arguments), + + _ => return Err(arguments.new_unexpected_token_error(Token::Ident(name))), + }?; + + arguments.expect_exhausted()?; + + Ok(color) +} + +/// Parse the alpha component by itself from either number or percentage, +/// clipping the result to [0.0..1.0]. +#[inline] +fn parse_alpha_component<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<f32, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + Ok(color_parser + .parse_number_or_percentage(arguments)? + .unit_value() + .clamp(0.0, OPAQUE)) +} + +fn parse_legacy_alpha<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<f32, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + Ok(if !arguments.is_exhausted() { + arguments.expect_comma()?; + parse_alpha_component(color_parser, arguments)? + } else { + OPAQUE + }) +} + +fn parse_modern_alpha<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<Option<f32>, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + if !arguments.is_exhausted() { + arguments.expect_delim('/')?; + parse_none_or(arguments, |p| parse_alpha_component(color_parser, p)) + } else { + Ok(Some(OPAQUE)) + } +} + +#[inline] +fn parse_rgb<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let maybe_red = parse_none_or(arguments, |p| color_parser.parse_number_or_percentage(p))?; + + // If the first component is not "none" and is followed by a comma, then we + // are parsing the legacy syntax. + let is_legacy_syntax = maybe_red.is_some() && arguments.try_parse(|p| p.expect_comma()).is_ok(); + + let (red, green, blue, alpha) = if is_legacy_syntax { + let (red, green, blue) = match maybe_red.unwrap() { + NumberOrPercentage::Number { value } => { + let red = clamp_floor_256_f32(value); + let green = clamp_floor_256_f32(color_parser.parse_number(arguments)?); + arguments.expect_comma()?; + let blue = clamp_floor_256_f32(color_parser.parse_number(arguments)?); + (red, green, blue) + } + NumberOrPercentage::Percentage { unit_value } => { + let red = clamp_unit_f32(unit_value); + let green = clamp_unit_f32(color_parser.parse_percentage(arguments)?); + arguments.expect_comma()?; + let blue = clamp_unit_f32(color_parser.parse_percentage(arguments)?); + (red, green, blue) + } + }; + + let alpha = parse_legacy_alpha(color_parser, arguments)?; + + (red, green, blue, alpha) + } else { + #[inline] + fn get_component_value(c: Option<NumberOrPercentage>) -> u8 { + c.map(|c| match c { + NumberOrPercentage::Number { value } => clamp_floor_256_f32(value), + NumberOrPercentage::Percentage { unit_value } => clamp_unit_f32(unit_value), + }) + .unwrap_or(0) + } + + let red = get_component_value(maybe_red); + + let green = get_component_value(parse_none_or(arguments, |p| { + color_parser.parse_number_or_percentage(p) + })?); + + let blue = get_component_value(parse_none_or(arguments, |p| { + color_parser.parse_number_or_percentage(p) + })?); + + let alpha = parse_modern_alpha(color_parser, arguments)?.unwrap_or(0.0); + + (red, green, blue, alpha) + }; + + Ok(P::Output::from_rgba(red, green, blue, alpha)) +} + +/// Parses hsl syntax. +/// +/// <https://drafts.csswg.org/css-color/#the-hsl-notation> +#[inline] +fn parse_hsl<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let maybe_hue = parse_none_or(arguments, |p| color_parser.parse_angle_or_number(p))?; + + // If the hue is not "none" and is followed by a comma, then we are parsing + // the legacy syntax. + let is_legacy_syntax = maybe_hue.is_some() && arguments.try_parse(|p| p.expect_comma()).is_ok(); + + let saturation: Option<f32>; + let lightness: Option<f32>; + + let alpha = if is_legacy_syntax { + saturation = Some(color_parser.parse_percentage(arguments)?); + arguments.expect_comma()?; + lightness = Some(color_parser.parse_percentage(arguments)?); + Some(parse_legacy_alpha(color_parser, arguments)?) + } else { + saturation = parse_none_or(arguments, |p| color_parser.parse_percentage(p))?; + lightness = parse_none_or(arguments, |p| color_parser.parse_percentage(p))?; + + parse_modern_alpha(color_parser, arguments)? + }; + + let hue = maybe_hue.map(|h| normalize_hue(h.degrees())); + let saturation = saturation.map(|s| s.clamp(0.0, 1.0)); + let lightness = lightness.map(|l| l.clamp(0.0, 1.0)); + + Ok(P::Output::from_hsl(hue, saturation, lightness, alpha)) +} + +/// Parses hwb syntax. +/// +/// <https://drafts.csswg.org/css-color/#the-hbw-notation> +#[inline] +fn parse_hwb<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let (hue, whiteness, blackness, alpha) = parse_components( + color_parser, + arguments, + P::parse_angle_or_number, + P::parse_percentage, + P::parse_percentage, + )?; + + let hue = hue.map(|h| normalize_hue(h.degrees())); + let whiteness = whiteness.map(|w| w.clamp(0.0, 1.0)); + let blackness = blackness.map(|b| b.clamp(0.0, 1.0)); + + Ok(P::Output::from_hwb(hue, whiteness, blackness, alpha)) +} + +/// <https://drafts.csswg.org/css-color-4/#hwb-to-rgb> +#[inline] +pub fn hwb_to_rgb(h: f32, w: f32, b: f32) -> (f32, f32, f32) { + if w + b >= 1.0 { + let gray = w / (w + b); + return (gray, gray, gray); + } + + // hue is expected in the range [0..1]. + let (mut red, mut green, mut blue) = hsl_to_rgb(h, 1.0, 0.5); + let x = 1.0 - w - b; + red = red * x + w; + green = green * x + w; + blue = blue * x + w; + (red, green, blue) +} + +/// <https://drafts.csswg.org/css-color/#hsl-color> +/// except with h pre-multiplied by 3, to avoid some rounding errors. +#[inline] +pub fn hsl_to_rgb(hue: f32, saturation: f32, lightness: f32) -> (f32, f32, f32) { + debug_assert!((0.0..=1.0).contains(&hue)); + + fn hue_to_rgb(m1: f32, m2: f32, mut h3: f32) -> f32 { + if h3 < 0. { + h3 += 3. + } + if h3 > 3. { + h3 -= 3. + } + if h3 * 2. < 1. { + m1 + (m2 - m1) * h3 * 2. + } else if h3 * 2. < 3. { + m2 + } else if h3 < 2. { + m1 + (m2 - m1) * (2. - h3) * 2. + } else { + m1 + } + } + let m2 = if lightness <= 0.5 { + lightness * (saturation + 1.) + } else { + lightness + saturation - lightness * saturation + }; + let m1 = lightness * 2. - m2; + let hue_times_3 = hue * 3.; + let red = hue_to_rgb(m1, m2, hue_times_3 + 1.); + let green = hue_to_rgb(m1, m2, hue_times_3); + let blue = hue_to_rgb(m1, m2, hue_times_3 - 1.); + (red, green, blue) +} + +type IntoColorFn<Output> = + fn(l: Option<f32>, a: Option<f32>, b: Option<f32>, alpha: Option<f32>) -> Output; + +#[inline] +fn parse_lab_like<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, + lightness_range: f32, + a_b_range: f32, + into_color: IntoColorFn<P::Output>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let (lightness, a, b, alpha) = parse_components( + color_parser, + arguments, + P::parse_number_or_percentage, + P::parse_number_or_percentage, + P::parse_number_or_percentage, + )?; + + let lightness = lightness.map(|l| l.value(lightness_range)); + let a = a.map(|a| a.value(a_b_range)); + let b = b.map(|b| b.value(a_b_range)); + + Ok(into_color(lightness, a, b, alpha)) +} + +#[inline] +fn parse_lch_like<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, + lightness_range: f32, + chroma_range: f32, + into_color: IntoColorFn<P::Output>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let (lightness, chroma, hue, alpha) = parse_components( + color_parser, + arguments, + P::parse_number_or_percentage, + P::parse_number_or_percentage, + P::parse_angle_or_number, + )?; + + let lightness = lightness.map(|l| l.value(lightness_range)); + let chroma = chroma.map(|c| c.value(chroma_range)); + let hue = hue.map(|h| normalize_hue(h.degrees())); + + Ok(into_color(lightness, chroma, hue, alpha)) +} + +/// Parse the color() function. +#[inline] +fn parse_color_with_color_space<'i, 't, P>( + color_parser: &P, + arguments: &mut Parser<'i, 't>, +) -> Result<P::Output, ParseError<'i, P::Error>> +where + P: ColorParser<'i>, +{ + let color_space = PredefinedColorSpace::parse(arguments)?; + + let (c1, c2, c3, alpha) = parse_components( + color_parser, + arguments, + P::parse_number_or_percentage, + P::parse_number_or_percentage, + P::parse_number_or_percentage, + )?; + + let c1 = c1.map(|c| c.unit_value()); + let c2 = c2.map(|c| c.unit_value()); + let c3 = c3.map(|c| c.unit_value()); + + Ok(P::Output::from_color_function( + color_space, + c1, + c2, + c3, + alpha, + )) +} + +type ComponentParseResult<'i, R1, R2, R3, Error> = + Result<(Option<R1>, Option<R2>, Option<R3>, Option<f32>), ParseError<'i, Error>>; + +/// Parse the color components and alpha with the modern [color-4] syntax. +pub fn parse_components<'i, 't, P, F1, F2, F3, R1, R2, R3>( + color_parser: &P, + input: &mut Parser<'i, 't>, + f1: F1, + f2: F2, + f3: F3, +) -> ComponentParseResult<'i, R1, R2, R3, P::Error> +where + P: ColorParser<'i>, + F1: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R1, ParseError<'i, P::Error>>, + F2: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R2, ParseError<'i, P::Error>>, + F3: FnOnce(&P, &mut Parser<'i, 't>) -> Result<R3, ParseError<'i, P::Error>>, +{ + let r1 = parse_none_or(input, |p| f1(color_parser, p))?; + let r2 = parse_none_or(input, |p| f2(color_parser, p))?; + let r3 = parse_none_or(input, |p| f3(color_parser, p))?; + + let alpha = parse_modern_alpha(color_parser, input)?; + + Ok((r1, r2, r3, alpha)) +} + +fn parse_none_or<'i, 't, F, T, E>(input: &mut Parser<'i, 't>, thing: F) -> Result<Option<T>, E> +where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>, +{ + match input.try_parse(|p| p.expect_ident_matching("none")) { + Ok(_) => Ok(None), + Err(_) => Ok(Some(thing(input)?)), + } +} + +/// A [`ModernComponent`] can serialize to `none`, `nan`, `infinity` and +/// floating point values. +struct ModernComponent<'a>(&'a Option<f32>); + +impl<'a> ToCss for ModernComponent<'a> { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + if let Some(value) = self.0 { + if value.is_finite() { + value.to_css(dest) + } else if value.is_nan() { + dest.write_str("calc(NaN)") + } else { + debug_assert!(value.is_infinite()); + if value.is_sign_negative() { + dest.write_str("calc(-infinity)") + } else { + dest.write_str("calc(infinity)") + } + } + } else { + dest.write_str("none") + } + } +} + +// Guaratees hue in [0..360) +fn normalize_hue(hue: f32) -> f32 { + // <https://drafts.csswg.org/css-values/#angles> + // Subtract an integer before rounding, to avoid some rounding errors: + hue - 360.0 * (hue / 360.0).floor() +} + +/// A color with red, green, blue, and alpha components, in a byte each. +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +#[derive(Clone, Copy, PartialEq, Debug)] +pub struct RgbaLegacy { + /// The red component. + pub red: u8, + /// The green component. + pub green: u8, + /// The blue component. + pub blue: u8, + /// The alpha component. + pub alpha: f32, +} + +impl RgbaLegacy { + /// Constructs a new RGBA value from float components. It expects the red, + /// green, blue and alpha channels in that order, and all values will be + /// clamped to the 0.0 ... 1.0 range. + #[inline] + pub fn from_floats(red: f32, green: f32, blue: f32, alpha: f32) -> Self { + Self::new( + clamp_unit_f32(red), + clamp_unit_f32(green), + clamp_unit_f32(blue), + alpha.clamp(0.0, OPAQUE), + ) + } + + /// Same thing, but with `u8` values instead of floats in the 0 to 1 range. + #[inline] + pub const fn new(red: u8, green: u8, blue: u8, alpha: f32) -> Self { + Self { + red, + green, + blue, + alpha, + } + } +} + +impl ToCss for RgbaLegacy { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + let has_alpha = self.alpha != OPAQUE; + + dest.write_str(if has_alpha { "rgba(" } else { "rgb(" })?; + self.red.to_css(dest)?; + dest.write_str(", ")?; + self.green.to_css(dest)?; + dest.write_str(", ")?; + self.blue.to_css(dest)?; + + // Legacy syntax does not allow none components. + serialize_color_alpha(dest, Some(self.alpha), true)?; + + dest.write_char(')') + } +} + +/// Color specified by hue, saturation and lightness components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Hsl { + /// The hue component. + pub hue: Option<f32>, + /// The saturation component. + pub saturation: Option<f32>, + /// The lightness component. + pub lightness: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +impl Hsl { + /// Construct a new HSL color from it's components. + pub fn new( + hue: Option<f32>, + saturation: Option<f32>, + lightness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Self { + hue, + saturation, + lightness, + alpha, + } + } +} + +impl ToCss for Hsl { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + // HSL serializes to RGB, so we have to convert it. + let (red, green, blue) = hsl_to_rgb( + self.hue.unwrap_or(0.0) / 360.0, + self.saturation.unwrap_or(0.0), + self.lightness.unwrap_or(0.0), + ); + + RgbaLegacy::from_floats(red, green, blue, self.alpha.unwrap_or(OPAQUE)).to_css(dest) + } +} + +/// Color specified by hue, whiteness and blackness components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Hwb { + /// The hue component. + pub hue: Option<f32>, + /// The whiteness component. + pub whiteness: Option<f32>, + /// The blackness component. + pub blackness: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +impl Hwb { + /// Construct a new HWB color from it's components. + pub fn new( + hue: Option<f32>, + whiteness: Option<f32>, + blackness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Self { + hue, + whiteness, + blackness, + alpha, + } + } +} + +impl ToCss for Hwb { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + // HWB serializes to RGB, so we have to convert it. + let (red, green, blue) = hwb_to_rgb( + self.hue.unwrap_or(0.0) / 360.0, + self.whiteness.unwrap_or(0.0), + self.blackness.unwrap_or(0.0), + ); + + RgbaLegacy::from_floats(red, green, blue, self.alpha.unwrap_or(OPAQUE)).to_css(dest) + } +} + +// NOTE: LAB and OKLAB is not declared inside the [impl_lab_like] macro, +// because it causes cbindgen to ignore them. + +/// Color specified by lightness, a- and b-axis components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Lab { + /// The lightness component. + pub lightness: Option<f32>, + /// The a-axis component. + pub a: Option<f32>, + /// The b-axis component. + pub b: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +/// Color specified by lightness, a- and b-axis components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Oklab { + /// The lightness component. + pub lightness: Option<f32>, + /// The a-axis component. + pub a: Option<f32>, + /// The b-axis component. + pub b: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +macro_rules! impl_lab_like { + ($cls:ident, $fname:literal) => { + impl $cls { + /// Construct a new Lab color format with lightness, a, b and alpha components. + pub fn new( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Self { + lightness, + a, + b, + alpha, + } + } + } + + impl ToCss for $cls { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + dest.write_str($fname)?; + dest.write_str("(")?; + ModernComponent(&self.lightness).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.a).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.b).to_css(dest)?; + serialize_color_alpha(dest, self.alpha, false)?; + dest.write_char(')') + } + } + }; +} + +impl_lab_like!(Lab, "lab"); +impl_lab_like!(Oklab, "oklab"); + +// NOTE: LCH and OKLCH is not declared inside the [impl_lch_like] macro, +// because it causes cbindgen to ignore them. + +/// Color specified by lightness, chroma and hue components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Lch { + /// The lightness component. + pub lightness: Option<f32>, + /// The chroma component. + pub chroma: Option<f32>, + /// The hue component. + pub hue: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +/// Color specified by lightness, chroma and hue components. +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct Oklch { + /// The lightness component. + pub lightness: Option<f32>, + /// The chroma component. + pub chroma: Option<f32>, + /// The hue component. + pub hue: Option<f32>, + /// The alpha component. + pub alpha: Option<f32>, +} + +macro_rules! impl_lch_like { + ($cls:ident, $fname:literal) => { + impl $cls { + /// Construct a new color with lightness, chroma and hue components. + pub fn new( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Self { + lightness, + chroma, + hue, + alpha, + } + } + } + + impl ToCss for $cls { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + dest.write_str($fname)?; + dest.write_str("(")?; + ModernComponent(&self.lightness).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.chroma).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.hue).to_css(dest)?; + serialize_color_alpha(dest, self.alpha, false)?; + dest.write_char(')') + } + } + }; +} + +impl_lch_like!(Lch, "lch"); +impl_lch_like!(Oklch, "oklch"); + +/// A color specified by the color() function. +/// <https://drafts.csswg.org/css-color-4/#color-function> +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +pub struct ColorFunction { + /// The color space for this color. + pub color_space: PredefinedColorSpace, + /// The first component of the color. Either red or x. + pub c1: Option<f32>, + /// The second component of the color. Either green or y. + pub c2: Option<f32>, + /// The third component of the color. Either blue or z. + pub c3: Option<f32>, + /// The alpha component of the color. + pub alpha: Option<f32>, +} + +impl ColorFunction { + /// Construct a new color function definition with the given color space and + /// color components. + pub fn new( + color_space: PredefinedColorSpace, + c1: Option<f32>, + c2: Option<f32>, + c3: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Self { + color_space, + c1, + c2, + c3, + alpha, + } + } +} + +impl ToCss for ColorFunction { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + dest.write_str("color(")?; + self.color_space.to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.c1).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.c2).to_css(dest)?; + dest.write_char(' ')?; + ModernComponent(&self.c3).to_css(dest)?; + + serialize_color_alpha(dest, self.alpha, false)?; + + dest.write_char(')') + } +} + +/// Describes one of the value <color> values according to the CSS +/// specification. +/// +/// Most components are `Option<_>`, so when the value is `None`, that component +/// serializes to the "none" keyword. +/// +/// <https://drafts.csswg.org/css-color-4/#color-type> +#[derive(Clone, Copy, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +#[cfg_attr(feature = "serde", serde(tag = "type"))] +pub enum Color { + /// The 'currentcolor' keyword. + CurrentColor, + /// Specify sRGB colors directly by their red/green/blue/alpha chanels. + Rgba(RgbaLegacy), + /// Specifies a color in sRGB using hue, saturation and lightness components. + Hsl(Hsl), + /// Specifies a color in sRGB using hue, whiteness and blackness components. + Hwb(Hwb), + /// Specifies a CIELAB color by CIE Lightness and its a- and b-axis hue + /// coordinates (red/green-ness, and yellow/blue-ness) using the CIE LAB + /// rectangular coordinate model. + Lab(Lab), + /// Specifies a CIELAB color by CIE Lightness, Chroma, and hue using the + /// CIE LCH cylindrical coordinate model. + Lch(Lch), + /// Specifies an Oklab color by Oklab Lightness and its a- and b-axis hue + /// coordinates (red/green-ness, and yellow/blue-ness) using the Oklab + /// rectangular coordinate model. + Oklab(Oklab), + /// Specifies an Oklab color by Oklab Lightness, Chroma, and hue using + /// the OKLCH cylindrical coordinate model. + Oklch(Oklch), + /// Specifies a color in a predefined color space. + ColorFunction(ColorFunction), +} + +impl ToCss for Color { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + match *self { + Color::CurrentColor => dest.write_str("currentcolor"), + Color::Rgba(rgba) => rgba.to_css(dest), + Color::Hsl(hsl) => hsl.to_css(dest), + Color::Hwb(hwb) => hwb.to_css(dest), + Color::Lab(lab) => lab.to_css(dest), + Color::Lch(lch) => lch.to_css(dest), + Color::Oklab(lab) => lab.to_css(dest), + Color::Oklch(lch) => lch.to_css(dest), + Color::ColorFunction(color_function) => color_function.to_css(dest), + } + } +} + +/// Either a number or a percentage. +pub enum NumberOrPercentage { + /// `<number>`. + Number { + /// The numeric value parsed, as a float. + value: f32, + }, + /// `<percentage>` + Percentage { + /// The value as a float, divided by 100 so that the nominal range is + /// 0.0 to 1.0. + unit_value: f32, + }, +} + +impl NumberOrPercentage { + /// Return the value as a percentage. + pub fn unit_value(&self) -> f32 { + match *self { + NumberOrPercentage::Number { value } => value, + NumberOrPercentage::Percentage { unit_value } => unit_value, + } + } + + /// Return the value as a number with a percentage adjusted to the + /// `percentage_basis`. + pub fn value(&self, percentage_basis: f32) -> f32 { + match *self { + Self::Number { value } => value, + Self::Percentage { unit_value } => unit_value * percentage_basis, + } + } +} + +/// Either an angle or a number. +pub enum AngleOrNumber { + /// `<number>`. + Number { + /// The numeric value parsed, as a float. + value: f32, + }, + /// `<angle>` + Angle { + /// The value as a number of degrees. + degrees: f32, + }, +} + +impl AngleOrNumber { + /// Return the angle in degrees. `AngleOrNumber::Number` is returned as + /// degrees, because it is the canonical unit. + pub fn degrees(&self) -> f32 { + match *self { + AngleOrNumber::Number { value } => value, + AngleOrNumber::Angle { degrees } => degrees, + } + } +} + +/// A trait that can be used to hook into how `cssparser` parses color +/// components, with the intention of implementing more complicated behavior. +/// +/// For example, this is used by Servo to support calc() in color. +pub trait ColorParser<'i> { + /// The type that the parser will construct on a successful parse. + type Output: FromParsedColor; + + /// A custom error type that can be returned from the parsing functions. + type Error: 'i; + + /// Parse an `<angle>` or `<number>`. + /// + /// Returns the result in degrees. + fn parse_angle_or_number<'t>( + &self, + input: &mut Parser<'i, 't>, + ) -> Result<AngleOrNumber, ParseError<'i, Self::Error>> { + let location = input.current_source_location(); + Ok(match *input.next()? { + Token::Number { value, .. } => AngleOrNumber::Number { value }, + Token::Dimension { + value: v, ref unit, .. + } => { + let degrees = match_ignore_ascii_case! { unit, + "deg" => v, + "grad" => v * 360. / 400., + "rad" => v * 360. / (2. * PI), + "turn" => v * 360., + _ => { + return Err(location.new_unexpected_token_error(Token::Ident(unit.clone()))) + } + }; + + AngleOrNumber::Angle { degrees } + } + ref t => return Err(location.new_unexpected_token_error(t.clone())), + }) + } + + /// Parse a `<percentage>` value. + /// + /// Returns the result in a number from 0.0 to 1.0. + fn parse_percentage<'t>( + &self, + input: &mut Parser<'i, 't>, + ) -> Result<f32, ParseError<'i, Self::Error>> { + input.expect_percentage().map_err(From::from) + } + + /// Parse a `<number>` value. + fn parse_number<'t>( + &self, + input: &mut Parser<'i, 't>, + ) -> Result<f32, ParseError<'i, Self::Error>> { + input.expect_number().map_err(From::from) + } + + /// Parse a `<number>` value or a `<percentage>` value. + fn parse_number_or_percentage<'t>( + &self, + input: &mut Parser<'i, 't>, + ) -> Result<NumberOrPercentage, ParseError<'i, Self::Error>> { + let location = input.current_source_location(); + Ok(match *input.next()? { + Token::Number { value, .. } => NumberOrPercentage::Number { value }, + Token::Percentage { unit_value, .. } => NumberOrPercentage::Percentage { unit_value }, + ref t => return Err(location.new_unexpected_token_error(t.clone())), + }) + } +} + +/// Default implementation of a [`ColorParser`] +pub struct DefaultColorParser; + +impl<'i> ColorParser<'i> for DefaultColorParser { + type Output = Color; + type Error = (); +} + +impl Color { + /// Parse a <color> value, per CSS Color Module Level 3. + /// + /// FIXME(#2) Deprecated CSS2 System Colors are not supported yet. + pub fn parse<'i>(input: &mut Parser<'i, '_>) -> Result<Color, ParseError<'i, ()>> { + parse_color_with(&DefaultColorParser, input) + } +} + +/// This trait is used by the [`ColorParser`] to construct colors of any type. +pub trait FromParsedColor { + /// Construct a new color from the CSS `currentcolor` keyword. + fn from_current_color() -> Self; + + /// Construct a new color from red, green, blue and alpha components. + fn from_rgba(red: u8, green: u8, blue: u8, alpha: f32) -> Self; + + /// Construct a new color from hue, saturation, lightness and alpha components. + fn from_hsl( + hue: Option<f32>, + saturation: Option<f32>, + lightness: Option<f32>, + alpha: Option<f32>, + ) -> Self; + + /// Construct a new color from hue, blackness, whiteness and alpha components. + fn from_hwb( + hue: Option<f32>, + whiteness: Option<f32>, + blackness: Option<f32>, + alpha: Option<f32>, + ) -> Self; + + /// Construct a new color from the `lab` notation. + fn from_lab(lightness: Option<f32>, a: Option<f32>, b: Option<f32>, alpha: Option<f32>) + -> Self; + + /// Construct a new color from the `lch` notation. + fn from_lch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self; + + /// Construct a new color from the `oklab` notation. + fn from_oklab( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self; + + /// Construct a new color from the `oklch` notation. + fn from_oklch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self; + + /// Construct a new color with a predefined color space. + fn from_color_function( + color_space: PredefinedColorSpace, + c1: Option<f32>, + c2: Option<f32>, + c3: Option<f32>, + alpha: Option<f32>, + ) -> Self; +} + +impl FromParsedColor for Color { + #[inline] + fn from_current_color() -> Self { + Color::CurrentColor + } + + #[inline] + fn from_rgba(red: u8, green: u8, blue: u8, alpha: f32) -> Self { + Color::Rgba(RgbaLegacy::new(red, green, blue, alpha)) + } + + fn from_hsl( + hue: Option<f32>, + saturation: Option<f32>, + lightness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Hsl(Hsl::new(hue, saturation, lightness, alpha)) + } + + fn from_hwb( + hue: Option<f32>, + blackness: Option<f32>, + whiteness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Hwb(Hwb::new(hue, blackness, whiteness, alpha)) + } + + #[inline] + fn from_lab( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Lab(Lab::new(lightness, a, b, alpha)) + } + + #[inline] + fn from_lch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Lch(Lch::new(lightness, chroma, hue, alpha)) + } + + #[inline] + fn from_oklab( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Oklab(Oklab::new(lightness, a, b, alpha)) + } + + #[inline] + fn from_oklch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::Oklch(Oklch::new(lightness, chroma, hue, alpha)) + } + + #[inline] + fn from_color_function( + color_space: PredefinedColorSpace, + c1: Option<f32>, + c2: Option<f32>, + c3: Option<f32>, + alpha: Option<f32>, + ) -> Self { + Color::ColorFunction(ColorFunction::new(color_space, c1, c2, c3, alpha)) + } +}
diff --git a/color/tests.rs b/color/tests.rs new file mode 100644 index 0000000..d8d8e5d --- /dev/null +++ b/color/tests.rs
@@ -0,0 +1,402 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use super::*; +use cssparser::ParserInput; +use serde_json::{json, Value}; + +fn almost_equals(a: &Value, b: &Value) -> bool { + match (a, b) { + (Value::Number(a), Value::Number(b)) => { + let a = a.as_f64().unwrap(); + let b = b.as_f64().unwrap(); + (a - b).abs() <= a.abs() * 1e-6 + } + + (&Value::Bool(a), &Value::Bool(b)) => a == b, + (Value::String(a), Value::String(b)) => a == b, + (Value::Array(a), Value::Array(b)) => { + a.len() == b.len() && a.iter().zip(b.iter()).all(|(a, b)| almost_equals(a, b)) + } + (&Value::Object(_), &Value::Object(_)) => panic!("Not implemented"), + (&Value::Null, &Value::Null) => true, + _ => false, + } +} + +fn assert_json_eq(results: Value, expected: Value, message: &str) { + if !almost_equals(&results, &expected) { + println!( + "{}", + ::difference::Changeset::new( + &serde_json::to_string_pretty(&results).unwrap(), + &serde_json::to_string_pretty(&expected).unwrap(), + "\n", + ) + ); + panic!("{}", message) + } +} + +fn run_raw_json_tests<F: Fn(Value, Value)>(json_data: &str, run: F) { + let items = match serde_json::from_str(json_data) { + Ok(Value::Array(items)) => items, + other => panic!("Invalid JSON: {:?}", other), + }; + assert!(items.len() % 2 == 0); + let mut input = None; + for item in items.into_iter() { + match (&input, item) { + (&None, json_obj) => input = Some(json_obj), + (&Some(_), expected) => { + let input = input.take().unwrap(); + run(input, expected) + } + }; + } +} + +fn run_json_tests<F: Fn(&mut Parser) -> Value>(json_data: &str, parse: F) { + run_raw_json_tests(json_data, |input, expected| match input { + Value::String(input) => { + let mut parse_input = ParserInput::new(&input); + let result = parse(&mut Parser::new(&mut parse_input)); + assert_json_eq(result, expected, &input); + } + _ => panic!("Unexpected JSON"), + }); +} +fn run_color_tests<F: Fn(Result<Color, ()>) -> Value>(json_data: &str, to_json: F) { + run_json_tests(json_data, |input| { + let result: Result<_, ParseError<()>> = + input.parse_entirely(|i| Color::parse(i).map_err(Into::into)); + to_json(result.map_err(|_| ())) + }); +} + +#[test] +fn color3() { + run_color_tests(include_str!("../src/css-parsing-tests/color3.json"), |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }) +} + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[test] +fn color3_hsl() { + run_color_tests( + include_str!("../src/css-parsing-tests/color3_hsl.json"), + |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }, + ) +} + +/// color3_keywords.json is different: R, G and B are in 0..255 rather than 0..1 +#[test] +fn color3_keywords() { + run_color_tests( + include_str!("../src/css-parsing-tests/color3_keywords.json"), + |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }, + ) +} + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[test] +fn color4_hwb() { + run_color_tests( + include_str!("../src/css-parsing-tests/color4_hwb.json"), + |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }, + ) +} + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[test] +fn color4_lab_lch_oklab_oklch() { + run_color_tests( + include_str!("../src/css-parsing-tests/color4_lab_lch_oklab_oklch.json"), + |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }, + ) +} + +#[test] +fn color4_color_function() { + run_color_tests( + include_str!("../src/css-parsing-tests/color4_color_function.json"), + |c| { + c.ok() + .map(|v| v.to_css_string().to_json()) + .unwrap_or(Value::Null) + }, + ) +} + +macro_rules! parse_single_color { + ($i:expr) => {{ + let input = $i; + let mut input = ParserInput::new(input); + let mut input = Parser::new(&mut input); + Color::parse(&mut input).map_err(Into::<ParseError<()>>::into) + }}; +} + +#[test] +fn color4_invalid_color_space() { + let result = parse_single_color!("color(invalid 1 1 1)"); + assert!(result.is_err()); +} + +#[test] +fn serialize_current_color() { + let c = Color::CurrentColor; + assert!(c.to_css_string() == "currentcolor"); +} + +#[test] +fn serialize_rgb_full_alpha() { + let c = Color::Rgba(RgbaLegacy::new(255, 230, 204, 1.0)); + assert_eq!(c.to_css_string(), "rgb(255, 230, 204)"); +} + +#[test] +fn serialize_rgba() { + let c = Color::Rgba(RgbaLegacy::new(26, 51, 77, 0.125)); + assert_eq!(c.to_css_string(), "rgba(26, 51, 77, 0.125)"); +} + +#[test] +fn serialize_rgba_two_digit_float_if_roundtrips() { + let c = Color::Rgba(RgbaLegacy::from_floats(0., 0., 0., 0.5)); + assert_eq!(c.to_css_string(), "rgba(0, 0, 0, 0.5)"); +} + +trait ToJson { + fn to_json(&self) -> Value; +} + +impl<T> ToJson for T +where + T: Clone, + Value: From<T>, +{ + fn to_json(&self) -> Value { + Value::from(self.clone()) + } +} + +impl ToJson for Color { + fn to_json(&self) -> Value { + match *self { + Color::CurrentColor => "currentcolor".to_json(), + Color::Rgba(ref rgba) => { + json!([rgba.red, rgba.green, rgba.blue, rgba.alpha]) + } + Color::Hsl(ref c) => json!([c.hue, c.saturation, c.lightness, c.alpha]), + Color::Hwb(ref c) => json!([c.hue, c.whiteness, c.blackness, c.alpha]), + Color::Lab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]), + Color::Lch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]), + Color::Oklab(ref c) => json!([c.lightness, c.a, c.b, c.alpha]), + Color::Oklch(ref c) => json!([c.lightness, c.chroma, c.hue, c.alpha]), + Color::ColorFunction(ref c) => { + json!([c.color_space.to_css_string(), c.c1, c.c2, c.c3, c.alpha]) + } + } + } +} + +#[test] +fn generic_parser() { + #[derive(Debug, PartialEq)] + enum OutputType { + CurrentColor, + Rgba(u8, u8, u8, f32), + Hsl(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + Hwb(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + Lab(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + Lch(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + Oklab(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + Oklch(Option<f32>, Option<f32>, Option<f32>, Option<f32>), + ColorFunction( + PredefinedColorSpace, + Option<f32>, + Option<f32>, + Option<f32>, + Option<f32>, + ), + } + + impl FromParsedColor for OutputType { + fn from_current_color() -> Self { + OutputType::CurrentColor + } + + fn from_rgba(red: u8, green: u8, blue: u8, alpha: f32) -> Self { + OutputType::Rgba(red, green, blue, alpha) + } + + fn from_hsl( + hue: Option<f32>, + saturation: Option<f32>, + lightness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Hsl(hue, saturation, lightness, alpha) + } + + fn from_hwb( + hue: Option<f32>, + blackness: Option<f32>, + whiteness: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Hwb(hue, blackness, whiteness, alpha) + } + + fn from_lab( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Lab(lightness, a, b, alpha) + } + + fn from_lch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Lch(lightness, chroma, hue, alpha) + } + + fn from_oklab( + lightness: Option<f32>, + a: Option<f32>, + b: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Oklab(lightness, a, b, alpha) + } + + fn from_oklch( + lightness: Option<f32>, + chroma: Option<f32>, + hue: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::Oklch(lightness, chroma, hue, alpha) + } + + fn from_color_function( + color_space: PredefinedColorSpace, + c1: Option<f32>, + c2: Option<f32>, + c3: Option<f32>, + alpha: Option<f32>, + ) -> Self { + OutputType::ColorFunction(color_space, c1, c2, c3, alpha) + } + } + + struct TestColorParser; + impl<'i> ColorParser<'i> for TestColorParser { + type Output = OutputType; + type Error = (); + } + + #[rustfmt::skip] + const TESTS: &[(&str, OutputType)] = &[ + ("currentColor", OutputType::CurrentColor), + ("rgb(1, 2, 3)", OutputType::Rgba(1, 2, 3, 1.0)), + ("rgba(1, 2, 3, 0.4)", OutputType::Rgba(1, 2, 3, 0.4)), + ("rgb(none none none / none)", OutputType::Rgba(0, 0, 0, 0.0)), + ("rgb(1 none 3 / none)", OutputType::Rgba(1, 0, 3, 0.0)), + + ("hsla(45deg, 20%, 30%, 0.4)", OutputType::Hsl(Some(45.0), Some(0.2), Some(0.3), Some(0.4))), + ("hsl(45deg none none)", OutputType::Hsl(Some(45.0), None, None, Some(1.0))), + ("hsl(none 10% none / none)", OutputType::Hsl(None, Some(0.1), None, None)), + ("hsl(120 100.0% 50.0%)", OutputType::Hsl(Some(120.0), Some(1.0), Some(0.5), Some(1.0))), + + ("hwb(45deg 20% 30% / 0.4)", OutputType::Hwb(Some(45.0), Some(0.2), Some(0.3), Some(0.4))), + + ("lab(100 20 30 / 0.4)", OutputType::Lab(Some(100.0), Some(20.0), Some(30.0), Some(0.4))), + ("lch(100 20 30 / 0.4)", OutputType::Lch(Some(100.0), Some(20.0), Some(30.0), Some(0.4))), + + ("oklab(100 20 30 / 0.4)", OutputType::Oklab(Some(100.0), Some(20.0), Some(30.0), Some(0.4))), + ("oklch(100 20 30 / 0.4)", OutputType::Oklch(Some(100.0), Some(20.0), Some(30.0), Some(0.4))), + + ("color(srgb 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::Srgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(srgb none none none)", OutputType::ColorFunction(PredefinedColorSpace::Srgb, None, None, None, Some(1.0))), + ("color(srgb none none none / none)", OutputType::ColorFunction(PredefinedColorSpace::Srgb, None, None, None, None)), + ("color(srgb-linear 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::SrgbLinear, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(display-p3 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::DisplayP3, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(a98-rgb 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::A98Rgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(prophoto-rgb 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::ProphotoRgb, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(rec2020 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::Rec2020, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(xyz-d50 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::XyzD50, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ("color(xyz-d65 0.1 0.2 0.3 / 0.4)", OutputType::ColorFunction(PredefinedColorSpace::XyzD65, Some(0.1), Some(0.2), Some(0.3), Some(0.4))), + ]; + + for (input, expected) in TESTS { + let mut input = ParserInput::new(input); + let mut input = Parser::new(&mut input); + + let actual: OutputType = parse_color_with(&TestColorParser, &mut input).unwrap(); + assert_eq!(actual, *expected); + } +} + +#[test] +fn serialize_modern_components() { + // None. + assert_eq!(ModernComponent(&None).to_css_string(), "none".to_string()); + + // Finite values. + assert_eq!( + ModernComponent(&Some(10.0)).to_css_string(), + "10".to_string() + ); + assert_eq!( + ModernComponent(&Some(-10.0)).to_css_string(), + "-10".to_string() + ); + assert_eq!(ModernComponent(&Some(0.0)).to_css_string(), "0".to_string()); + assert_eq!( + ModernComponent(&Some(-0.0)).to_css_string(), + "0".to_string() + ); + + // Infinite values. + assert_eq!( + ModernComponent(&Some(f32::INFINITY)).to_css_string(), + "calc(infinity)".to_string() + ); + assert_eq!( + ModernComponent(&Some(f32::NEG_INFINITY)).to_css_string(), + "calc(-infinity)".to_string() + ); + + // NaN. + assert_eq!( + ModernComponent(&Some(f32::NAN)).to_css_string(), + "calc(NaN)".to_string() + ); +}
diff --git a/docs/.nojekyll b/docs/.nojekyll new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/docs/.nojekyll
diff --git a/docs/404.html b/docs/404.html new file mode 100644 index 0000000..bf70be1 --- /dev/null +++ b/docs/404.html
@@ -0,0 +1,3 @@ +<meta http-equiv="refresh" content="0; url=https://docs.rs/cssparser/"> +<link rel="canonical" href="https://docs.rs/cssparser/"> +<a href="https://docs.rs/cssparser/">Moved to docs.rs</a>
diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..bf70be1 --- /dev/null +++ b/docs/index.html
@@ -0,0 +1,3 @@ +<meta http-equiv="refresh" content="0; url=https://docs.rs/cssparser/"> +<link rel="canonical" href="https://docs.rs/cssparser/"> +<a href="https://docs.rs/cssparser/">Moved to docs.rs</a>
diff --git a/fuzz/.gitignore b/fuzz/.gitignore new file mode 100644 index 0000000..572e03b --- /dev/null +++ b/fuzz/.gitignore
@@ -0,0 +1,4 @@ + +target +corpus +artifacts
diff --git a/fuzz/Cargo.lock b/fuzz/Cargo.lock new file mode 100644 index 0000000..da45b9a --- /dev/null +++ b/fuzz/Cargo.lock
@@ -0,0 +1,266 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "arbitrary" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "698b65a961a9d730fb45b6b0327e20207810c9f61ee421b082b27ba003f49e2b" + +[[package]] +name = "cc" +version = "1.0.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "cssparser" +version = "0.28.1" +dependencies = [ + "cssparser-macros", + "dtoa-short", + "itoa", + "matches", + "phf", + "proc-macro2", + "quote", + "smallvec", + "syn", +] + +[[package]] +name = "cssparser-fuzz" +version = "0.0.0" +dependencies = [ + "cssparser", + "libfuzzer-sys", +] + +[[package]] +name = "cssparser-macros" +version = "0.6.0" +dependencies = [ + "quote", + "syn", +] + +[[package]] +name = "dtoa" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88d7ed2934d741c6b37e33e3832298e8850b53fd2d2bea03873375596c7cea4e" + +[[package]] +name = "dtoa-short" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bde03329ae10e79ede66c9ce4dc930aa8599043b0743008548680f25b91502d6" +dependencies = [ + "dtoa", +] + +[[package]] +name = "getrandom" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "itoa" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736" + +[[package]] +name = "libc" +version = "0.2.88" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03b07a082330a35e43f63177cc01689da34fbffa0105e1246cf0311472cac73a" + +[[package]] +name = "libfuzzer-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86c975d637bc2a2f99440932b731491fc34c7f785d239e38af3addd3c2fd0e46" +dependencies = [ + "arbitrary", + "cc", +] + +[[package]] +name = "matches" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08" + +[[package]] +name = "phf" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12" +dependencies = [ + "phf_macros", + "phf_shared", + "proc-macro-hack", +] + +[[package]] +name = "phf_generator" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526" +dependencies = [ + "phf_shared", + "rand", +] + +[[package]] +name = "phf_macros" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c" +dependencies = [ + "phf_generator", + "phf_shared", + "proc-macro-hack", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "phf_shared" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7" +dependencies = [ + "siphasher", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857" + +[[package]] +name = "proc-macro-hack" +version = "0.5.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" + +[[package]] +name = "proc-macro2" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom", + "libc", + "rand_chacha", + "rand_core", + "rand_hc", + "rand_pcg", +] + +[[package]] +name = "rand_chacha" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core", +] + +[[package]] +name = "rand_pcg" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429" +dependencies = [ + "rand_core", +] + +[[package]] +name = "siphasher" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa8f3741c7372e75519bd9346068370c9cdaabcc1f9599cbcf2a2719352286b7" + +[[package]] +name = "smallvec" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e" + +[[package]] +name = "syn" +version = "1.0.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd9bc7ccc2688b3344c2f48b9b546648b25ce0b20fc717ee7fa7981a8ca9717" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "unicode-xid" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml new file mode 100644 index 0000000..ebe2036 --- /dev/null +++ b/fuzz/Cargo.toml
@@ -0,0 +1,26 @@ + +[package] +name = "cssparser-fuzz" +version = "0.0.0" +authors = ["Automatically generated"] +publish = false +edition = "2018" + +[package.metadata] +cargo-fuzz = true + +[dependencies] +libfuzzer-sys = "0.4" + +[dependencies.cssparser] +path = ".." + +# Prevent this from interfering with workspaces +[workspace] +members = ["."] + +[[bin]] +name = "cssparser" +path = "fuzz_targets/cssparser.rs" +test = false +doc = false
diff --git a/fuzz/fuzz_targets/cssparser.rs b/fuzz/fuzz_targets/cssparser.rs new file mode 100644 index 0000000..6299a14 --- /dev/null +++ b/fuzz/fuzz_targets/cssparser.rs
@@ -0,0 +1,96 @@ +#![no_main] + +use cssparser::*; + +const DEBUG: bool = false; + +fn parse_and_serialize(input: &str, preserving_comments: bool) -> String { + let mut input = ParserInput::new(input); + let mut parser = Parser::new(&mut input); + let mut serialization = String::new(); + let result = do_parse_and_serialize( + &mut parser, + preserving_comments, + TokenSerializationType::nothing(), + &mut serialization, + 0, + ); + if result.is_err() { + return String::new(); + } + serialization +} + +fn do_parse_and_serialize<'i>( + input: &mut Parser<'i, '_>, + preserving_comments: bool, + mut previous_token_type: TokenSerializationType, + serialization: &mut String, + indent_level: usize, +) -> Result<(), ParseError<'i, ()>> { + loop { + let token = if preserving_comments { + input.next_including_whitespace_and_comments() + } else { + input.next_including_whitespace() + }; + let token = match token { + Ok(token) => token, + Err(..) => break, + }; + if DEBUG { + for _ in 0..indent_level { + print!(" "); + } + println!("{:?}", token); + } + if token.is_parse_error() { + let token = token.clone(); + return Err(input.new_unexpected_token_error(token)) + } + let token_type = token.serialization_type(); + if previous_token_type.needs_separator_when_before(token_type) { + serialization.push_str("/**/"); + } + previous_token_type = token_type; + token.to_css(serialization).unwrap(); + let closing_token = match token { + Token::Function(_) | Token::ParenthesisBlock => Token::CloseParenthesis, + Token::SquareBracketBlock => Token::CloseSquareBracket, + Token::CurlyBracketBlock => Token::CloseCurlyBracket, + _ => continue, + }; + + input.parse_nested_block(|input| -> Result<_, ParseError<()>> { + do_parse_and_serialize(input, preserving_comments, previous_token_type, serialization, indent_level + 1) + })?; + + closing_token.to_css(serialization).unwrap(); + } + Ok(()) +} + +fn fuzz(data: &str, preserving_comments: bool) { + let serialization = parse_and_serialize(data, preserving_comments); + let reserialization = parse_and_serialize(&serialization, preserving_comments); + if DEBUG { + println!("IN: {:?}", serialization); + println!("OUT: {:?}", reserialization); + } + // TODO: This should ideally pass, but it doesn't for numbers near our + // precision limits, so parsing e.g., 9999995e-45 generates a serialization + // of 10e-39 because of dtoa rounding, and parsing _that_ generates a + // serialization of 1e-38. + // + // assert_eq!( + // serialization, reserialization, + // "Serialization should be idempotent" + // ); +} + +libfuzzer_sys::fuzz_target!(|data: &str| { + fuzz(data, false); + // TODO(emilio): Serialization when preserving comments is not idempotent. + // But in browsers we never preserve comments so that's ok... + // fuzz(data, true); +});
diff --git a/macros/Cargo.toml b/macros/Cargo.toml new file mode 100644 index 0000000..494705f --- /dev/null +++ b/macros/Cargo.toml
@@ -0,0 +1,17 @@ +[package] +name = "cssparser-macros" +version = "0.6.1" +authors = ["Simon Sapin <simon.sapin@exyr.org>"] +description = "Procedural macros for cssparser" +documentation = "https://docs.rs/cssparser-macros/" +repository = "https://github.com/servo/rust-cssparser" +license = "MPL-2.0" +edition = "2018" + +[lib] +path = "lib.rs" +proc-macro = true + +[dependencies] +quote = "1.0.29" +syn = {version = "2", features = ["full", "extra-traits"]}
diff --git a/macros/LICENSE b/macros/LICENSE new file mode 120000 index 0000000..ea5b606 --- /dev/null +++ b/macros/LICENSE
@@ -0,0 +1 @@ +../LICENSE \ No newline at end of file
diff --git a/macros/lib.rs b/macros/lib.rs new file mode 100644 index 0000000..8b40bd4 --- /dev/null +++ b/macros/lib.rs
@@ -0,0 +1,190 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +extern crate proc_macro; + +use proc_macro::TokenStream; + +#[proc_macro] +pub fn _cssparser_internal_max_len(input: TokenStream) -> TokenStream { + struct Input { + max_length: usize, + } + + impl syn::parse::Parse for Input { + fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> { + let mut max_length = 0; + while !input.is_empty() { + if input.peek(syn::Token![_]) { + input.parse::<syn::Token![_]>().unwrap(); + continue; + } + let lit: syn::LitStr = input.parse()?; + let value = lit.value(); + if value.to_ascii_lowercase() != value { + return Err(syn::Error::new(lit.span(), "must be ASCII-lowercase")); + } + max_length = max_length.max(value.len()); + } + Ok(Input { max_length }) + } + } + + let Input { max_length } = syn::parse_macro_input!(input); + quote::quote!( + pub(super) const MAX_LENGTH: usize = #max_length; + ) + .into() +} + +fn get_byte_from_lit(lit: &syn::Lit) -> u8 { + if let syn::Lit::Byte(ref byte) = *lit { + byte.value() + } else { + panic!("Found a pattern that wasn't a byte") + } +} + +fn get_byte_from_expr_lit(expr: &syn::Expr) -> u8 { + match *expr { + syn::Expr::Lit(syn::ExprLit { ref lit, .. }) => get_byte_from_lit(lit), + _ => unreachable!(), + } +} + +/// Parse a pattern and fill the table accordingly +fn parse_pat_to_table<'a>( + pat: &'a syn::Pat, + case_id: u8, + wildcard: &mut Option<&'a syn::Ident>, + table: &mut [u8; 256], +) { + match pat { + syn::Pat::Lit(syn::PatLit { ref lit, .. }) => { + let value = get_byte_from_lit(lit); + if table[value as usize] == 0 { + table[value as usize] = case_id; + } + } + syn::Pat::Range(syn::PatRange { + ref start, ref end, .. + }) => { + let lo = get_byte_from_expr_lit(start.as_ref().unwrap()); + let hi = get_byte_from_expr_lit(end.as_ref().unwrap()); + for value in lo..hi { + if table[value as usize] == 0 { + table[value as usize] = case_id; + } + } + if table[hi as usize] == 0 { + table[hi as usize] = case_id; + } + } + syn::Pat::Wild(_) => { + for byte in table.iter_mut() { + if *byte == 0 { + *byte = case_id; + } + } + } + syn::Pat::Ident(syn::PatIdent { ref ident, .. }) => { + assert_eq!(*wildcard, None); + *wildcard = Some(ident); + for byte in table.iter_mut() { + if *byte == 0 { + *byte = case_id; + } + } + } + syn::Pat::Or(syn::PatOr { ref cases, .. }) => { + for case in cases { + parse_pat_to_table(case, case_id, wildcard, table); + } + } + _ => { + panic!("Unexpected pattern: {:?}. Buggy code ?", pat); + } + } +} + +/// Expand a TokenStream corresponding to the `match_byte` macro. +/// +/// ## Example +/// +/// ```rust +/// match_byte! { tokenizer.next_byte_unchecked(), +/// b'a'..b'z' => { ... } +/// b'0'..b'9' => { ... } +/// b'\n' | b'\\' => { ... } +/// foo => { ... } +/// } +/// ``` +/// +#[proc_macro] +pub fn match_byte(input: TokenStream) -> TokenStream { + use syn::spanned::Spanned; + struct MatchByte { + expr: syn::Expr, + arms: Vec<syn::Arm>, + } + + impl syn::parse::Parse for MatchByte { + fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> { + Ok(MatchByte { + expr: { + let expr = input.parse()?; + input.parse::<syn::Token![,]>()?; + expr + }, + arms: { + let mut arms = Vec::new(); + while !input.is_empty() { + let arm = input.call(syn::Arm::parse)?; + assert!(arm.guard.is_none(), "match_byte doesn't support guards"); + assert!( + arm.attrs.is_empty(), + "match_byte doesn't support attributes" + ); + arms.push(arm); + } + arms + }, + }) + } + } + let MatchByte { expr, arms } = syn::parse_macro_input!(input); + + let mut cases = Vec::new(); + let mut table = [0u8; 256]; + let mut match_body = Vec::new(); + let mut wildcard = None; + for (i, ref arm) in arms.iter().enumerate() { + let case_id = i + 1; + let index = case_id as isize; + let name = syn::Ident::new(&format!("Case{}", case_id), arm.span()); + let pat = &arm.pat; + parse_pat_to_table(pat, case_id as u8, &mut wildcard, &mut table); + + cases.push(quote::quote!(#name = #index)); + let body = &arm.body; + match_body.push(quote::quote!(Case::#name => { #body })) + } + + let en = quote::quote!(enum Case { + #(#cases),* + }); + + let mut table_content = Vec::new(); + for entry in table.iter() { + let name: syn::Path = syn::parse_str(&format!("Case::Case{}", entry)).unwrap(); + table_content.push(name); + } + let table = quote::quote!(static __CASES: [Case; 256] = [#(#table_content),*];); + + if let Some(binding) = wildcard { + quote::quote!({ #en #table let #binding = #expr; match __CASES[#binding as usize] { #(#match_body),* }}) + } else { + quote::quote!({ #en #table match __CASES[#expr as usize] { #(#match_body),* }}) + }.into() +}
diff --git a/src/big-data-url.css b/src/big-data-url.css new file mode 100644 index 0000000..dd0f922 --- /dev/null +++ b/src/big-data-url.css
@@ -0,0 +1 @@ +url(data:image/png;base64,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)
diff --git a/src/color.rs b/src/color.rs new file mode 100644 index 0000000..978936e --- /dev/null +++ b/src/color.rs
@@ -0,0 +1,348 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//! General color-parsing utilities, independent on the specific color storage and parsing +//! implementation. +//! +//! For a more complete css-color implementation take a look at cssparser-color crate, or at +//! Gecko's color module. + +// Allow text like <color> in docs. +#![allow(rustdoc::invalid_html_tags)] + +/// The opaque alpha value of 1.0. +pub const OPAQUE: f32 = 1.0; + +use crate::{BasicParseError, Parser, ToCss, Token}; +use std::fmt; + +/// Clamp a 0..1 number to a 0..255 range to u8. +/// +/// Whilst scaling by 256 and flooring would provide +/// an equal distribution of integers to percentage inputs, +/// this is not what Gecko does so we instead multiply by 255 +/// and round (adding 0.5 and flooring is equivalent to rounding) +/// +/// Chrome does something similar for the alpha value, but not +/// the rgb values. +/// +/// See <https://bugzilla.mozilla.org/show_bug.cgi?id=1340484> +/// +/// Clamping to 256 and rounding after would let 1.0 map to 256, and +/// `256.0_f32 as u8` is undefined behavior: +/// +/// <https://github.com/rust-lang/rust/issues/10184> +#[inline] +pub fn clamp_unit_f32(val: f32) -> u8 { + clamp_floor_256_f32(val * 255.) +} + +/// Round and clamp a single number to a u8. +#[inline] +pub fn clamp_floor_256_f32(val: f32) -> u8 { + val.round().clamp(0., 255.) as u8 +} + +/// Serialize the alpha copmonent of a color according to the specification. +/// <https://drafts.csswg.org/css-color-4/#serializing-alpha-values> +#[inline] +pub fn serialize_color_alpha( + dest: &mut impl fmt::Write, + alpha: Option<f32>, + legacy_syntax: bool, +) -> fmt::Result { + let alpha = match alpha { + None => return dest.write_str(" / none"), + Some(a) => a, + }; + + // If the alpha component is full opaque, don't emit the alpha value in CSS. + if alpha == OPAQUE { + return Ok(()); + } + + dest.write_str(if legacy_syntax { ", " } else { " / " })?; + + // Try first with two decimal places, then with three. + let mut rounded_alpha = (alpha * 100.).round() / 100.; + if clamp_unit_f32(rounded_alpha) != clamp_unit_f32(alpha) { + rounded_alpha = (alpha * 1000.).round() / 1000.; + } + + rounded_alpha.to_css(dest) +} + +/// A Predefined color space specified in: +/// <https://drafts.csswg.org/css-color-4/#predefined> +#[derive(Clone, Copy, Eq, PartialEq, Debug)] +#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))] +#[cfg_attr(feature = "serde", serde(tag = "type"))] +pub enum PredefinedColorSpace { + /// <https://drafts.csswg.org/css-color-4/#predefined-sRGB> + Srgb, + /// <https://drafts.csswg.org/css-color-4/#predefined-sRGB-linear> + SrgbLinear, + /// <https://drafts.csswg.org/css-color-4/#predefined-display-p3> + DisplayP3, + /// <https://drafts.csswg.org/css-color-4/#predefined-a98-rgb> + A98Rgb, + /// <https://drafts.csswg.org/css-color-4/#predefined-prophoto-rgb> + ProphotoRgb, + /// <https://drafts.csswg.org/css-color-4/#predefined-rec2020> + Rec2020, + /// <https://drafts.csswg.org/css-color-4/#predefined-xyz> + XyzD50, + /// <https://drafts.csswg.org/css-color-4/#predefined-xyz> + XyzD65, +} + +impl PredefinedColorSpace { + /// Parse a PredefinedColorSpace from the given input. + pub fn parse<'i>(input: &mut Parser<'i, '_>) -> Result<Self, BasicParseError<'i>> { + let location = input.current_source_location(); + + let ident = input.expect_ident()?; + Ok(match_ignore_ascii_case! { ident, + "srgb" => Self::Srgb, + "srgb-linear" => Self::SrgbLinear, + "display-p3" => Self::DisplayP3, + "a98-rgb" => Self::A98Rgb, + "prophoto-rgb" => Self::ProphotoRgb, + "rec2020" => Self::Rec2020, + "xyz-d50" => Self::XyzD50, + "xyz" | "xyz-d65" => Self::XyzD65, + _ => return Err(location.new_basic_unexpected_token_error(Token::Ident(ident.clone()))), + }) + } +} + +impl ToCss for PredefinedColorSpace { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + dest.write_str(match self { + Self::Srgb => "srgb", + Self::SrgbLinear => "srgb-linear", + Self::DisplayP3 => "display-p3", + Self::A98Rgb => "a98-rgb", + Self::ProphotoRgb => "prophoto-rgb", + Self::Rec2020 => "rec2020", + Self::XyzD50 => "xyz-d50", + Self::XyzD65 => "xyz-d65", + }) + } +} + +/// Parse a color hash, without the leading '#' character. +#[allow(clippy::result_unit_err)] +#[inline] +pub fn parse_hash_color(value: &[u8]) -> Result<(u8, u8, u8, f32), ()> { + Ok(match value.len() { + 8 => ( + from_hex(value[0])? * 16 + from_hex(value[1])?, + from_hex(value[2])? * 16 + from_hex(value[3])?, + from_hex(value[4])? * 16 + from_hex(value[5])?, + (from_hex(value[6])? * 16 + from_hex(value[7])?) as f32 / 255.0, + ), + 6 => ( + from_hex(value[0])? * 16 + from_hex(value[1])?, + from_hex(value[2])? * 16 + from_hex(value[3])?, + from_hex(value[4])? * 16 + from_hex(value[5])?, + OPAQUE, + ), + 4 => ( + from_hex(value[0])? * 17, + from_hex(value[1])? * 17, + from_hex(value[2])? * 17, + (from_hex(value[3])? * 17) as f32 / 255.0, + ), + 3 => ( + from_hex(value[0])? * 17, + from_hex(value[1])? * 17, + from_hex(value[2])? * 17, + OPAQUE, + ), + _ => return Err(()), + }) +} + +ascii_case_insensitive_phf_map! { + named_colors -> (u8, u8, u8) = { + "black" => (0, 0, 0), + "silver" => (192, 192, 192), + "gray" => (128, 128, 128), + "white" => (255, 255, 255), + "maroon" => (128, 0, 0), + "red" => (255, 0, 0), + "purple" => (128, 0, 128), + "fuchsia" => (255, 0, 255), + "green" => (0, 128, 0), + "lime" => (0, 255, 0), + "olive" => (128, 128, 0), + "yellow" => (255, 255, 0), + "navy" => (0, 0, 128), + "blue" => (0, 0, 255), + "teal" => (0, 128, 128), + "aqua" => (0, 255, 255), + + "aliceblue" => (240, 248, 255), + "antiquewhite" => (250, 235, 215), + "aquamarine" => (127, 255, 212), + "azure" => (240, 255, 255), + "beige" => (245, 245, 220), + "bisque" => (255, 228, 196), + "blanchedalmond" => (255, 235, 205), + "blueviolet" => (138, 43, 226), + "brown" => (165, 42, 42), + "burlywood" => (222, 184, 135), + "cadetblue" => (95, 158, 160), + "chartreuse" => (127, 255, 0), + "chocolate" => (210, 105, 30), + "coral" => (255, 127, 80), + "cornflowerblue" => (100, 149, 237), + "cornsilk" => (255, 248, 220), + "crimson" => (220, 20, 60), + "cyan" => (0, 255, 255), + "darkblue" => (0, 0, 139), + "darkcyan" => (0, 139, 139), + "darkgoldenrod" => (184, 134, 11), + "darkgray" => (169, 169, 169), + "darkgreen" => (0, 100, 0), + "darkgrey" => (169, 169, 169), + "darkkhaki" => (189, 183, 107), + "darkmagenta" => (139, 0, 139), + "darkolivegreen" => (85, 107, 47), + "darkorange" => (255, 140, 0), + "darkorchid" => (153, 50, 204), + "darkred" => (139, 0, 0), + "darksalmon" => (233, 150, 122), + "darkseagreen" => (143, 188, 143), + "darkslateblue" => (72, 61, 139), + "darkslategray" => (47, 79, 79), + "darkslategrey" => (47, 79, 79), + "darkturquoise" => (0, 206, 209), + "darkviolet" => (148, 0, 211), + "deeppink" => (255, 20, 147), + "deepskyblue" => (0, 191, 255), + "dimgray" => (105, 105, 105), + "dimgrey" => (105, 105, 105), + "dodgerblue" => (30, 144, 255), + "firebrick" => (178, 34, 34), + "floralwhite" => (255, 250, 240), + "forestgreen" => (34, 139, 34), + "gainsboro" => (220, 220, 220), + "ghostwhite" => (248, 248, 255), + "gold" => (255, 215, 0), + "goldenrod" => (218, 165, 32), + "greenyellow" => (173, 255, 47), + "grey" => (128, 128, 128), + "honeydew" => (240, 255, 240), + "hotpink" => (255, 105, 180), + "indianred" => (205, 92, 92), + "indigo" => (75, 0, 130), + "ivory" => (255, 255, 240), + "khaki" => (240, 230, 140), + "lavender" => (230, 230, 250), + "lavenderblush" => (255, 240, 245), + "lawngreen" => (124, 252, 0), + "lemonchiffon" => (255, 250, 205), + "lightblue" => (173, 216, 230), + "lightcoral" => (240, 128, 128), + "lightcyan" => (224, 255, 255), + "lightgoldenrodyellow" => (250, 250, 210), + "lightgray" => (211, 211, 211), + "lightgreen" => (144, 238, 144), + "lightgrey" => (211, 211, 211), + "lightpink" => (255, 182, 193), + "lightsalmon" => (255, 160, 122), + "lightseagreen" => (32, 178, 170), + "lightskyblue" => (135, 206, 250), + "lightslategray" => (119, 136, 153), + "lightslategrey" => (119, 136, 153), + "lightsteelblue" => (176, 196, 222), + "lightyellow" => (255, 255, 224), + "limegreen" => (50, 205, 50), + "linen" => (250, 240, 230), + "magenta" => (255, 0, 255), + "mediumaquamarine" => (102, 205, 170), + "mediumblue" => (0, 0, 205), + "mediumorchid" => (186, 85, 211), + "mediumpurple" => (147, 112, 219), + "mediumseagreen" => (60, 179, 113), + "mediumslateblue" => (123, 104, 238), + "mediumspringgreen" => (0, 250, 154), + "mediumturquoise" => (72, 209, 204), + "mediumvioletred" => (199, 21, 133), + "midnightblue" => (25, 25, 112), + "mintcream" => (245, 255, 250), + "mistyrose" => (255, 228, 225), + "moccasin" => (255, 228, 181), + "navajowhite" => (255, 222, 173), + "oldlace" => (253, 245, 230), + "olivedrab" => (107, 142, 35), + "orange" => (255, 165, 0), + "orangered" => (255, 69, 0), + "orchid" => (218, 112, 214), + "palegoldenrod" => (238, 232, 170), + "palegreen" => (152, 251, 152), + "paleturquoise" => (175, 238, 238), + "palevioletred" => (219, 112, 147), + "papayawhip" => (255, 239, 213), + "peachpuff" => (255, 218, 185), + "peru" => (205, 133, 63), + "pink" => (255, 192, 203), + "plum" => (221, 160, 221), + "powderblue" => (176, 224, 230), + "rebeccapurple" => (102, 51, 153), + "rosybrown" => (188, 143, 143), + "royalblue" => (65, 105, 225), + "saddlebrown" => (139, 69, 19), + "salmon" => (250, 128, 114), + "sandybrown" => (244, 164, 96), + "seagreen" => (46, 139, 87), + "seashell" => (255, 245, 238), + "sienna" => (160, 82, 45), + "skyblue" => (135, 206, 235), + "slateblue" => (106, 90, 205), + "slategray" => (112, 128, 144), + "slategrey" => (112, 128, 144), + "snow" => (255, 250, 250), + "springgreen" => (0, 255, 127), + "steelblue" => (70, 130, 180), + "tan" => (210, 180, 140), + "thistle" => (216, 191, 216), + "tomato" => (255, 99, 71), + "turquoise" => (64, 224, 208), + "violet" => (238, 130, 238), + "wheat" => (245, 222, 179), + "whitesmoke" => (245, 245, 245), + "yellowgreen" => (154, 205, 50), + } +} + +/// Returns the named color with the given name. +/// <https://drafts.csswg.org/css-color-4/#typedef-named-color> +#[allow(clippy::result_unit_err)] +#[inline] +pub fn parse_named_color(ident: &str) -> Result<(u8, u8, u8), ()> { + named_colors::get(ident).copied().ok_or(()) +} + +/// Returns an iterator over all named CSS colors. +/// <https://drafts.csswg.org/css-color-4/#typedef-named-color> +#[inline] +pub fn all_named_colors() -> impl Iterator<Item = (&'static str, (u8, u8, u8))> { + named_colors::entries().map(|(k, v)| (*k, *v)) +} + +#[inline] +fn from_hex(c: u8) -> Result<u8, ()> { + match c { + b'0'..=b'9' => Ok(c - b'0'), + b'a'..=b'f' => Ok(c - b'a' + 10), + b'A'..=b'F' => Ok(c - b'A' + 10), + _ => Err(()), + } +}
diff --git a/src/cow_rc_str.rs b/src/cow_rc_str.rs new file mode 100644 index 0000000..03631f4 --- /dev/null +++ b/src/cow_rc_str.rs
@@ -0,0 +1,185 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use std::borrow::{Borrow, Cow}; +use std::rc::Rc; +use std::{cmp, fmt, hash, marker, mem, ops, ptr, slice, str}; + +/// A string that is either shared (heap-allocated and reference-counted) or borrowed. +/// +/// Equivalent to `enum { Borrowed(&'a str), Shared(Rc<String>) }`, but stored more compactly. +/// +/// * If `borrowed_len_or_max == usize::MAX`, then `ptr` represents `NonZero<*const String>` +/// from `Rc::into_raw`. +/// The lifetime parameter `'a` is irrelevant in this case. +/// +/// * Otherwise, `ptr` represents the `NonZero<*const u8>` data component of `&'a str`, +/// and `borrowed_len_or_max` its length. +pub struct CowRcStr<'a> { + ptr: ptr::NonNull<()>, + borrowed_len_or_max: usize, + + phantom: marker::PhantomData<Result<&'a str, Rc<String>>>, +} + +fn _static_assert_same_size() { + // "Instantiate" the generic function without calling it. + let _ = mem::transmute::<CowRcStr<'_>, Option<CowRcStr<'_>>>; +} + +impl<'a> From<Cow<'a, str>> for CowRcStr<'a> { + #[inline] + fn from(s: Cow<'a, str>) -> Self { + match s { + Cow::Borrowed(s) => CowRcStr::from(s), + Cow::Owned(s) => CowRcStr::from(s), + } + } +} + +impl<'a> From<&'a str> for CowRcStr<'a> { + #[inline] + fn from(s: &'a str) -> Self { + let len = s.len(); + assert!(len < usize::MAX); + CowRcStr { + ptr: unsafe { ptr::NonNull::new_unchecked(s.as_ptr() as *mut ()) }, + borrowed_len_or_max: len, + phantom: marker::PhantomData, + } + } +} + +impl From<String> for CowRcStr<'_> { + #[inline] + fn from(s: String) -> Self { + CowRcStr::from_rc(Rc::new(s)) + } +} + +impl<'a> CowRcStr<'a> { + #[inline] + fn from_rc(s: Rc<String>) -> Self { + let ptr = unsafe { ptr::NonNull::new_unchecked(Rc::into_raw(s) as *mut ()) }; + CowRcStr { + ptr, + borrowed_len_or_max: usize::MAX, + phantom: marker::PhantomData, + } + } + + #[inline] + fn unpack(&self) -> Result<&'a str, *const String> { + if self.borrowed_len_or_max == usize::MAX { + Err(self.ptr.as_ptr() as *const String) + } else { + unsafe { + Ok(str::from_utf8_unchecked(slice::from_raw_parts( + self.ptr.as_ptr() as *const u8, + self.borrowed_len_or_max, + ))) + } + } + } +} + +impl Clone for CowRcStr<'_> { + #[inline] + fn clone(&self) -> Self { + match self.unpack() { + Err(ptr) => { + let rc = unsafe { Rc::from_raw(ptr) }; + let new_rc = rc.clone(); + mem::forget(rc); // Don’t actually take ownership of this strong reference + CowRcStr::from_rc(new_rc) + } + Ok(_) => CowRcStr { ..*self }, + } + } +} + +impl Drop for CowRcStr<'_> { + #[inline] + fn drop(&mut self) { + if let Err(ptr) = self.unpack() { + mem::drop(unsafe { Rc::from_raw(ptr) }) + } + } +} + +impl ops::Deref for CowRcStr<'_> { + type Target = str; + + #[inline] + fn deref(&self) -> &str { + self.unpack().unwrap_or_else(|ptr| unsafe { &**ptr }) + } +} + +// Boilerplate / trivial impls below. + +impl AsRef<str> for CowRcStr<'_> { + #[inline] + fn as_ref(&self) -> &str { + self + } +} + +impl Borrow<str> for CowRcStr<'_> { + #[inline] + fn borrow(&self) -> &str { + self + } +} + +impl Default for CowRcStr<'_> { + #[inline] + fn default() -> Self { + Self::from("") + } +} + +impl hash::Hash for CowRcStr<'_> { + #[inline] + fn hash<H: hash::Hasher>(&self, hasher: &mut H) { + str::hash(self, hasher) + } +} + +impl<T: AsRef<str>> PartialEq<T> for CowRcStr<'_> { + #[inline] + fn eq(&self, other: &T) -> bool { + str::eq(self, other.as_ref()) + } +} + +impl<T: AsRef<str>> PartialOrd<T> for CowRcStr<'_> { + #[inline] + fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> { + str::partial_cmp(self, other.as_ref()) + } +} + +impl Eq for CowRcStr<'_> {} + +impl Ord for CowRcStr<'_> { + #[inline] + fn cmp(&self, other: &Self) -> cmp::Ordering { + str::cmp(self, other) + } +} + +impl fmt::Display for CowRcStr<'_> { + #[inline] + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + str::fmt(self, formatter) + } +} + +impl fmt::Debug for CowRcStr<'_> { + #[inline] + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + str::fmt(self, formatter) + } +}
diff --git a/src/css-parsing-tests/An+B.json b/src/css-parsing-tests/An+B.json new file mode 100644 index 0000000..b1ecf35 --- /dev/null +++ b/src/css-parsing-tests/An+B.json
@@ -0,0 +1,158 @@ +[ + +"", null, +" \n", null, + +"odd", [2, 1], +"even", [2, 0], +"ödd", null, +"éven", null, +" /**/\t OdD /**/\n", [2, 1], +" /**/\t EveN /**/\n", [2, 0], + + +"3", [0, 3], +"+2 ", [0, 2], +" -14 ", [0, -14], +"+ 2 ", null, +"- 14 ", null, +"3.1", null, + +"3N", [3, 0], +"+2N ", [2, 0], +" -14n ", [-14, 0], +"+ 2N ", null, +"- 14N ", null, +"3.1N", null, +"3 n", null, + +" N", [1, 0], +" +n", [1, 0], +" -n", [-1, 0], +"+ n", null, +"- n", null, + + +"3N+1", [3, 1], +"+2n+1 ", [2, 1], +" -14n+1 ", [-14, 1], +"+ 2N+1 ", null, +"- 14n+1 ", null, +"3.1n+1", null, +"3 n+1", null, + +" n+1", [1, 1], +" +N+1", [1, 1], +" -n+1", [-1, 1], +"+ N+1", null, +"- N+1", null, + +"3n-1", [3, -1], +"+2N-1 ", [2, -1], +" -14n-1 ", [-14, -1], +"+ 2N-1 ", null, +"- 14N-1 ", null, +"3.1n-1", null, +"3 n-1", null, +"3n-1foo", null, + +" n-1", [1, -1], +" +n-1", [1, -1], +" -n-1", [-1, -1], +"+ n-1", null, +"- n-1", null, +" +n-1foo", null, +" -n-1foo", null, + + +"3N +1", [3, 1], +"+2N +1 ", [2, 1], +" -14n +1 ", [-14, 1], +"+ 2N +1 ", null, +"- 14n +1 ", null, +"3.1N +1", null, +"3 n +1", null, +"3n foo", null, +"3n + foo", null, + +" n +1", [1, 1], +" +N +1", [1, 1], +" -n +1", [-1, 1], +"+ n +1", null, +"- N +1", null, + +"3N -1", [3, -1], +"+2n -1 ", [2, -1], +" -14n -1 ", [-14, -1], +"+ 2n -1 ", null, +"- 14N -1 ", null, +"3.1N -1", null, +"3 N -1", null, + +" N -1", [1, -1], +" +N -1", [1, -1], +" -n -1", [-1, -1], +"+ n -1", null, +"- n -1", null, + + +"3n+ 1", [3, 1], +"+2n+ 1 ", [2, 1], +" -14n+ 1 ", [-14, 1], +"+ 2n+ 1 ", null, +"- 14N+ 1 ", null, +"3.1n+ 1", null, +"3 N+ 1", null, + +" N+ 1", [1, 1], +" +N+ 1", [1, 1], +" -N+ 1", [-1, 1], +"+ n+ 1", null, +"- N+ 1", null, + +"3n- 1", [3, -1], +"+2N- 1 ", [2, -1], +" -14N- 1 ", [-14, -1], +"+ 2N- 1 ", null, +"- 14n- 1 ", null, +"3.1n- 1", null, +"3 n- 1", null, + +" N- 1", [1, -1], +" +N- 1", [1, -1], +" -n- 1", [-1, -1], +"+ n- 1", null, +"- N- 1", null, + + +"3N + 1", [3, 1], +"+2N + 1 ", [2, 1], +" -14n + 1 ", [-14, 1], +"+ 2n + 1 ", null, +"- 14N + 1 ", null, +"3.1n + 1", null, +"3 N + 1", null, + +" n + 1", [1, 1], +" +n + 1", [1, 1], +" -N + 1", [-1, 1], +"+ N + 1", null, +"- N + 1", null, + +"3N - 1", [3, -1], +"+2n - 1 ", [2, -1], +" -14n - 1 ", [-14, -1], +"+ 2N - 1 ", null, +"- 14N - 1 ", null, +"3.1N - 1", null, +"3 n - 1", null, + +" N - 1", [1, -1], +" +n - 1", [1, -1], +" -n - 1", [-1, -1], +"+ N - 1", null, +"- N - 1", null, + +"2n\u22121", null + +]
diff --git a/src/css-parsing-tests/LICENSE b/src/css-parsing-tests/LICENSE new file mode 100644 index 0000000..bfe03af --- /dev/null +++ b/src/css-parsing-tests/LICENSE
@@ -0,0 +1,8 @@ +Written in 2013 by Simon Sapin. + +To the extent possible under law, the author(s) have dedicated all copyright +and related and neighboring rights to this work to the public domain worldwide. +This work is distributed without any warranty. + +See the CC0 Public Domain Dedication: +http://creativecommons.org/publicdomain/zero/1.0/
diff --git a/src/css-parsing-tests/README.rst b/src/css-parsing-tests/README.rst new file mode 100644 index 0000000..8e358c6 --- /dev/null +++ b/src/css-parsing-tests/README.rst
@@ -0,0 +1,301 @@ +CSS parsing tests +################# + +This repository contains implementation-independent test for CSS parsers, +based on the 2013 draft of the `CSS Syntax Level 3`_ specification. + +.. _CSS Syntax Level 3: https://drafts.csswg.org/css-syntax-3/ + +The upstream repository for these tests is at +https://github.com/SimonSapin/css-parsing-tests + + +Projects using this +=================== + +CSS parsers using these tests: + +* `tinycss2 <https://github.com/SimonSapin/tinycss2>`_ (Python) +* `rust-cssparser <https://github.com/mozilla-servo/rust-cssparser>`_ + (Rust, used in `Servo <https://github.com/mozilla/servo/>`_) +* `Crass <https://github.com/rgrove/crass/>`_ (Ruby) + + +Importing +========= + +The recommended way to use these tests in an implementation +is to import them with git-subtree_. + +.. _git-subtree: https://github.com/git/git/tree/master/contrib/subtree + +To import the first time to a ``./css-parsing-tests`` sub-directory, +run this from the top-level of a git repository:: + + git subtree add -P css-parsing-tests https://github.com/SimonSapin/css-parsing-tests.git master + +Later, to merge changes made in the upstream repository, run:: + + git subtree pull -P css-parsing-tests https://github.com/SimonSapin/css-parsing-tests.git master + + +Test files +========== + +CSS Syntax specification describes a number of "functions". +Each ``.json`` file in this repository corresponds to such a function. +The files are encoded as UTF-8 +and each contain a JSON array with an even number of items, +where each pair of items is one function input +associated with the expected result. + +``component_value_list.json`` + Tests `Parse a list of component values + <https://drafts.csswg.org/css-syntax-3/#parse-a-list-of-component-values>`_. + The Unicode input is represented by a JSON string, + the output as an array of `component values`_ as described below. + +``component_value_list.json`` + Tests `Parse a component value + <https://drafts.csswg.org/css-syntax-3/#parse-a-component-value>`_. + The Unicode input is represented by a JSON string, + the output as a `component value`_. + +``declaration_list.json`` + Tests `Parse a list of declarations + <https://drafts.csswg.org/css-syntax-3/#parse-a-list-of-declarations>`_. + The Unicode input is represented by a JSON string, + the output as an array of declarations_ and at-rules_. + +``one_declaration.json`` + Tests `Parse a declaration + <https://drafts.csswg.org/css-syntax-3/#parse-a-declaration>`_. + The Unicode input is represented by a JSON string, + the output as a declaration_. + +``one_rule.json`` + Tests `Parse a rule + <https://drafts.csswg.org/css-syntax-3/#parse-a-rule>`_. + The Unicode input is represented by a JSON string, + the output as a `qualified rule`_ or at-rule_. + +``rule_list.json`` + Tests `Parse a list of rules + <https://drafts.csswg.org/css-syntax-3/#parse-a-list-of-rules>`_. + The Unicode input is represented by a JSON string, + the output as a list of `qualified rules`_ or at-rules_. + +``stylesheet.json`` + Tests `Parse a stylesheet + <https://drafts.csswg.org/css-syntax-3/#parse-a-stylesheet>`_. + The Unicode input is represented by a JSON string, + the output as a list of `qualified rules`_ or at-rules_. + +``stylesheet_bytes.json`` + Tests `Parse a stylesheet + <https://drafts.csswg.org/css-syntax-3/#parse-a-stylesheet>`_ + together with `The input byte stream + <https://drafts.csswg.org/css-syntax-3/#input-byte-stream>`_. + The input is represented as a JSON object containing: + + * A required ``css_bytes``, the input byte string, + represented as a JSON string where code points U+0000 to U+00FF + represent bytes of the same value. + * An optional ``protocol_encoding``, + a protocol encoding label as a JSON string, or null. + * An optional ``environment_encoding``, + an environment encoding label as a JSON string, or null. + * An optional ``comment`` that is ignored. + + The output is represented a list of `qualified rules`_ or at-rules_. + +``color3.json`` + Tests the ``<color>`` syntax `defined in CSS Color Level 3 + <http://www.w3.org/TR/css3-color/#colorunits>`_. + The Unicode input is represented by a JSON string, + the output as one of: + + * null if the input is not a valid color in CSS syntax + * The string "currentcolor" for the currentcolor keyword + * An array of length 4 for every other values: + four (floating point) numbers for the Red, Green, Blue and Alpha channel. + Each value is between 0 and 1. + +``color3_hsl.json`` + Same as ``color3.json``. + This file is generated by the ``make_color3_hsl.py`` Python script. + +``color3_keywords.json`` + Same as ``color3.json``, + except that the values for the Red, Green and Blue channel + are between 0 and 255. + This file is generated by the ``make_color3_keywords.py`` Python script. + +``An+B.json`` + Tests the `An+B <https://drafts.csswg.org/css-syntax-3/#the-anb-type>`_ + syntax defined in CSS Syntax Level 3. + This `differs <https://drafts.csswg.org/css-syntax/#changes>`_ from the + `nth grammar rule <http://www.w3.org/TR/css3-selectors/#nth-child-pseudo>`_ + in Selectors Level 3 only in that + ``-`` characters and digits can be escaped in some cases. + The Unicode input is represented by a JSON string, + the output as null for invalid syntax, + or an array of two integers ``[A, B]``. + +``urange.json`` + Tests the `urange <https://drafts.csswg.org/css-syntax-3/#urange>`_ + syntax defined in CSS Syntax Level 3. + The Unicode input is represented by a JSON string, + the output as null for invalid syntax, + or an array of two integers ``[start, end]``. + + +Result representation +===================== + +AST nodes (the results of parsing) are represented in JSON as follow. +This representation was chosen to be compact +(and thus less annoying to write by hand) +while staying unambiguous. +For example, the difference between ``@import`` and ``\@import`` is not lost: +they are represented as ``["at-keyword", "import"]`` and ``["ident", "@import"]``, +respectively. + + +Rules and declarations +---------------------- + +.. _at-rule: +.. _at-rules: +.. _qualified rule: +.. _qualified rules: +.. _declaration: +.. _declarations: + + +At-rule + An array of length 4: the string ``"at-rule"``, + the name (value of the at-keyword) as a string, + the prelude as a nested array of `component values`_, + and the optional block as a nested array of component value, or null. + +Qualified rule + An array of length 3: the string ``"qualified rule"``, + the prelude as a nested array of `component values`_, + and the block as a nested array of component value. + + +Declaration + An array of length 4: the string ``"declaration"``, the name as a string, + the value as a nested array of `component values`_, + and a the important flag as a boolean. + + +.. _component value: +.. _component values: + +Component values +---------------- + +<ident> + Array of length 2: the string ``"ident"``, and the value as a string. + +<at-keyword> + Array of length 2: the string ``"at-keyword"``, and the value as a string. + +<hash> + Array of length 3: the string ``"hash"``, the value as a string, + and the type as the string ``"id"`` or ``"unrestricted"``. + +<string> + Array of length 2: the string ``"string"``, and the value as a string. + +<bad-string> + Array of length 1: the string ``"bad-string"``. + +<url> + Array of length 2: the string ``"url"``, and the value as a string. + +<bad-url> + Array of length 1: the string ``"bad-url"``. + +<delim> + The value as a one-character string. + +<number> + Array of length 4: the string ``"number"``, the representation as a string, + the value as a number, and the type as the string ``"integer"`` or ``"number"``. + +<percentage> + Array of length 4: the string ``"percentage"``, the representation as a string, + the value as a number, and the type as the string ``"integer"`` or ``"number"``. + +<dimension> + Array of length 4: the string ``"dimension"``, the representation as a string, + the value as a number, the type as the string ``"integer"`` or ``"number"``, + and the unit as a string. + +<include-match> + The string ``"~="``. + +<dash-match> + The string ``"|="``. + +<prefix-match> + The string ``"^="``. + +<suffix-match> + The string ``"$="``. + +<substring-match> + The string ``"*="``. + +<whitespace> + The string ``" "`` (a single space.) + +<CDO> + The string ``"<!--"``. + +<CDC> + The string ``"-->"``. + +<colon> + The string ``":"``. + +<semicolon> + The string ``";"``. + +<comma> + The string ``","``. + +{} block + An array of length N+1: the string ``"{}"`` + followed by the N `component values`_ of the block’s content. + +[] block + An array of length N+1: the string ``"[]"`` + followed by the N `component values`_ of the block’s content. + +() block + An array of length N+1: the string ``"()"`` + followed by the N `component values`_ of the block’s content. + +Function + An array of length N+2: the string ``"function"`` + and the name of the function as a string + followed by the N `component values`_ of the function’s arguments. + +<bad-string> + The array of two strings ``["error", "bad-string"]``. + +<bad-url> + The array of two strings ``["error", "bad-url"]``. + +Unmatched <}> + The array of two strings ``["error", "}"]``. + +Unmatched <]> + The array of two strings ``["error", "]"]``. + +Unmatched <)> + The array of two strings ``["error", ")"]``.
diff --git a/src/css-parsing-tests/color3.json b/src/css-parsing-tests/color3.json new file mode 100644 index 0000000..a189b9b --- /dev/null +++ b/src/css-parsing-tests/color3.json
@@ -0,0 +1,261 @@ +[ +"", null, +" /* hey */\n", null, +"4", null, +"top", null, +"/**/transparent", "rgba(0, 0, 0, 0)", +"transparent", "rgba(0, 0, 0, 0)", +" transparent\n", "rgba(0, 0, 0, 0)", +"TransParent", "rgba(0, 0, 0, 0)", +"currentcolor", "currentcolor", +"currentColor", "currentcolor", +"CURRENTcolor", "currentcolor", +"current-Color", null, + +"black", "rgb(0, 0, 0)", +"white", "rgb(255, 255, 255)", +"fuchsia", "rgb(255, 0, 255)", +"cyan", "rgb(0, 255, 255)", +"CyAn", "rgb(0, 255, 255)", + +"#", null, +"#f", null, +"#ff", null, +"#fff", "rgb(255, 255, 255)", +"#ffg", null, +"#ffff", "rgb(255, 255, 255)", +"#fffg", null, +"#fffff", null, +"#ffffff", "rgb(255, 255, 255)", +"#fffffg", null, +"#fffffff", null, +"#ffffffff", "rgb(255, 255, 255)", +"#fffffffg", null, +"#fffffffff", null, + +"#FFCc99", "rgb(255, 204, 153)", +"#369", "rgb(51, 102, 153)", + + "#ffé", null, "#fffffé", null, + +"rgb(00, 51, 102)", "rgb(0, 51, 102)", +"r\\gb(00, 51, 102)", "rgb(0, 51, 102)", +"r\\67 b(00, 51, 102)", "rgb(0, 51, 102)", +"RGB(153, 204,255)", "rgb(153, 204, 255)", +"rgB(0, 0, 0)", "rgb(0, 0, 0)", +"rgB(0, 51,255)", "rgb(0, 51, 255)", +"rgb(0,51,255)", "rgb(0, 51, 255)", +"rgb(0\t, 51 ,255)", "rgb(0, 51, 255)", +"rgb(/* R */0, /* G */51, /* B */255)", "rgb(0, 51, 255)", +"rgb(-51, 306, 0)", "rgb(0, 255, 0)", + +"rgb(12.5%, 25%, 50%)", "rgb(32, 64, 128)", +"RGB(100%, 100%, 100%)", "rgb(255, 255, 255)", +"rgB(0%, 0%, 0%)", "rgb(0, 0, 0)", +"rgB(37.5%, 75%, 0%)", "rgb(96, 191, 0)", +"rgb(37.5%,75%,0%)", "rgb(96, 191, 0)", +"rgb(37.5%\t, 75%, 0%)", "rgb(96, 191, 0)", +"rgb(/* R */ 37.5%, /* G */ 75%, /* B */ 0%)", "rgb(96, 191, 0)", +"rgb(-12%, 110%, 1400%)", "rgb(0, 255, 255)", + +"rgb(10%, 50%, 0)", null, +"rgb(255, 50%, 0%)", null, +"rgb(0, 0 0)", null, +"rgb(0, 0, 0deg)", null, +"rgb(0, 0, light)", null, +"rgb()", null, +"rgb(0)", null, +"rgb(0, 0)", null, +"rgb(0, 0, 0, 0)", "rgba(0, 0, 0, 0)", +"rgb(0%)", null, +"rgb(0%, 0%)", null, +"rgb(0%, 0%, 0%, 0%)", "rgba(0, 0, 0, 0)", +"rgb(0%, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", + +"rgba(0, 0, 0, 0)", "rgba(0, 0, 0, 0)", + "rgba(.3, -1.4, -0.001e2, 0)", "rgba(0, 0, 0, 0)", +"rgba(204, 0, 102, 0.25)", "rgba(204, 0, 102, 0.25)", +"RGBA(255,255,255, 0)", "rgba(255, 255, 255, 0)", +"rgBA(0, 51,255, 1)", "rgb(0, 51, 255)", +"rgba(0, 51,255, 1.1)", "rgb(0, 51, 255)", +"rgba(0, 51,255, 37)", "rgb(0, 51, 255)", +"rgba(0, 51,255, 0.5)", "rgba(0, 51, 255, 0.5)", +"rgba(0, 51,255, 0)", "rgba(0, 51, 255, 0)", +"rgba(0, 51,255, -0.1)", "rgba(0, 51, 255, 0)", +"rgba(0, 51,255, -139)", "rgba(0, 51, 255, 0)", + +"rgba(12.5%, 25%, 50%, 0.25)", "rgba(32, 64, 128, 0.25)", +"RGBA(100%, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", +"rgBA(0%, 20%, 100%, 1)", "rgb(0, 51, 255)", +"rgba(0%, 20%, 100%, 1.1)", "rgb(0, 51, 255)", +"rgba(0%, 20%, 100%, 37)", "rgb(0, 51, 255)", +"rgba(0%, 20%, 100%, 0.25)", "rgba(0, 51, 255, 0.25)", +"rgba(0%, 20%, 100%, 0)", "rgba(0, 51, 255, 0)", +"rgba(0%, 20%, 100%, -0.1)", "rgba(0, 51, 255, 0)", +"rgba(0%, 20%, 100%, -139)", "rgba(0, 51, 255, 0)", + +"rgba(255,255,255, 0%)", "rgba(255, 255, 255, 0)", +"rgba(10%, 50%, 0, 1)", null, +"rgba(255, 50%, 0%, 1)", null, +"rgba(0, 0, 0 0)", null, +"rgba(0, 0, 0, 0deg)", null, +"rgba(0, 0, 0, light)", null, +"rgba()", null, +"rgba(0)", null, +"rgba(0, 0, 0)", "rgb(0, 0, 0)", +"rgba(0, 0, 0, 0, 0)", null, +"rgba(0%)", null, +"rgba(0%, 0%)", null, +"rgba(0%, 0%, 0%)", "rgb(0, 0, 0)", +"rgba(0%, 0%, 0%, 0%)", "rgba(0, 0, 0, 0)", +"rgba(0%, 0%, 0%, 0%, 0%)", null, + +"HSL(0, 0%, 0%)", "rgb(0, 0, 0)", +"hsL(0, 100%, 50%)", "rgb(255, 0, 0)", +"hsl(60, 100%, 37.5%)", "rgb(191, 191, 0)", +"hsl(780, 100%, 37.5%)", "rgb(191, 191, 0)", +"hsl(-300, 100%, 37.5%)", "rgb(191, 191, 0)", +"hsl(300, 50%, 50%)", "rgb(191, 64, 191)", + +"hsl(10, 50%, 0)", null, +"hsl(50%, 50%, 0%)", null, +"hsl(0, 0% 0%)", null, +"hsl(30deg, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 0%, light)", null, +"hsl()", null, +"hsl(0)", null, +"hsl(0, 0%)", null, +"hsl(0, 0%, 0%, 0%)", "rgba(0, 0, 0, 0)", + +"HSLA(-300, 100%, 37.5%, 1)", "rgb(191, 191, 0)", +"hsLA(-300, 100%, 37.5%, 12)", "rgb(191, 191, 0)", +"hsla(-300, 100%, 37.5%, 0.2)", "rgba(191, 191, 0, 0.2)", +"hsla(-300, 100%, 37.5%, 0)", "rgba(191, 191, 0, 0)", +"hsla(-300, 100%, 37.5%, -3)", "rgba(191, 191, 0, 0)", + +"hsla(10, 50%, 0, 1)", null, +"hsla(50%, 50%, 0%, 1)", null, +"hsla(0, 0% 0%, 1)", null, +"hsla(30deg, 100%, 100%, 1)", "rgb(255, 255, 255)", +"hsla(0, 0%, light, 1)", null, +"hsla()", null, +"hsla(0)", null, +"hsla(0, 0%)", null, +"hsla(0, 0%, 0%, 50%)", "rgba(0, 0, 0, 0.5)", +"hsla(0, 0%, 0%, 255, 0%)", null, + +"rgb(0 0 0 0)", null, +"rgb(0 0 0 / 0)", "rgba(0, 0, 0, 0)", +"rgb(0%)", null, +"rgb(0% 0%)", null, +"rgb(0% 0% 0% / 0%)", "rgba(0, 0, 0, 0)", +"rgb(0% 0% 0% / 0)", "rgba(0, 0, 0, 0)", + +"rgba(0%)", null, +"rgba(0% 0%)", null, +"rgba(0% 0% 0%)", "rgb(0, 0, 0)", +"rgba(0% 0% 0% / 0%)", "rgba(0, 0, 0, 0)", +"rgba(0% 0% 0% / 0% 0%)", null, + +"rgb(0, 0 0 0)", null, +"rgb(0 0, 0 0)", null, +"rgb(0 0 0, 0)", null, +"rgb(0, 0, 0 0)", null, + +"rgba(0%, 0% 0%)", null, +"rgba(0% 0% 0%, 0%)", null, + +"HSL(0 0% 0%)", "rgb(0, 0, 0)", +"hsL(0 100% 50%)", "rgb(255, 0, 0)", +"hsl(60 100% 37.5%)", "rgb(191, 191, 0)", + +"HSLA(-300 100% 37.5% /1)", "rgb(191, 191, 0)", +"hsLA(-300 100% 37.5% /12)", "rgb(191, 191, 0)", + +"hsl(0, 0 0 0)", null, +"hsl(0 0, 0 0)", null, +"hsl(0 0 0, 0)", null, +"hsl(0, 0, 0 0)", null, + +"hsla(0%, 0% 0%)", null, +"hsla(0% 0% 0%, 0%)", null, + +"hsla(120.0, 75%, 50%, 20%)", "rgba(32, 223, 32, 0.2)", +"hsla(120, 75%, 50%, 0.4)", "rgba(32, 223, 32, 0.4)", +"hsla(120 75% 50% / 60%)", "rgba(32, 223, 32, 0.6)", +"hsla(120.0 75% 50% / 1.0)", "rgb(32, 223, 32)", +"hsla(120/* comment */75%/* comment */50%/1.0)", "rgb(32, 223, 32)", +"hsla(120,/* comment */75%,/* comment */50%,100%)", "rgb(32, 223, 32)", +"hsla(120.0, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(120 75% 50%)", "rgb(32, 223, 32)", +"hsla(120/* comment */75%/* comment */50%)", "rgb(32, 223, 32)", +"hsla(120/* comment */,75%,/* comment */50%)", "rgb(32, 223, 32)", +"hsl(120, 75%, 50%, 0.2)", "rgba(32, 223, 32, 0.2)", +"hsl(120, 75%, 50%, 40%)", "rgba(32, 223, 32, 0.4)", +"hsl(120 75% 50% / 0.6)", "rgba(32, 223, 32, 0.6)", +"hsl(120 75% 50% / 80%)", "rgba(32, 223, 32, 0.8)", +"hsl(120/* comment */75%/* comment */50%/1.0)", "rgb(32, 223, 32)", +"hsl(120/* comment */75%/* comment */50%/100%)", "rgb(32, 223, 32)", +"hsl(120,/* comment */75%,/* comment */50%,1.0)", "rgb(32, 223, 32)", +"hsl(120,/* comment */75%,/* comment */50%,100%)", "rgb(32, 223, 32)", +"hsl(120/* comment */75%/* comment */50%)", "rgb(32, 223, 32)", +"hsl(120/* comment */,75%,/* comment */50%)", "rgb(32, 223, 32)", +"hsla(120, 75%, 50%, 0.2)", "rgba(32, 223, 32, 0.2)", +"hsl(240, 75%, 50%)", "rgb(32, 32, 223)", +"hsla(120, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(120.0, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(1.2e2, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(1.2E2, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(60, 75%, 50%)", "rgb(223, 223, 32)", +"hsl(120, 75%, 50%, 0.2)", "rgba(32, 223, 32, 0.2)", +"hsl(120.0, 75%, 50%, 0.4)", "rgba(32, 223, 32, 0.4)", +"hsl(1.2e2, 75%, 50%, 0.6)", "rgba(32, 223, 32, 0.6)", +"hsl(1.2E2, 75%, 50%, 0.8)", "rgba(32, 223, 32, 0.8)", +"hsl(60.0, 75%, 50%, 1.0)", "rgb(223, 223, 32)", +"rgb(10%, 60%, 10%, 20%)", "rgba(26, 153, 26, 0.2)", +"rgb(10, 175, 10, 0.4)", "rgba(10, 175, 10, 0.4)", +"rgb(10 175 10 / 60%)", "rgba(10, 175, 10, 0.6)", +"rgb(10.0 175.0 10.0 / 0.8)", "rgba(10, 175, 10, 0.8)", +"rgb(10/* comment */175/* comment */10/100%)", "rgb(10, 175, 10)", +"rgb(10,/* comment */150,/* comment */50)", "rgb(10, 150, 50)", +"rgb(10%, 60%, 10%)", "rgb(26, 153, 26)", +"rgb(10.0 100.0 100.0)", "rgb(10, 100, 100)", +"rgb(10/* comment */75/* comment */125)", "rgb(10, 75, 125)", +"rgb(10.0, 50.0, 150.0)", "rgb(10, 50, 150)", +"rgba(10.0, 175.0, 10.0, 0.2)", "rgba(10, 175, 10, 0.2)", +"rgba(10, 175, 10, 40%)", "rgba(10, 175, 10, 0.4)", +"rgba(10% 75% 10% / 0.6)", "rgba(26, 191, 26, 0.6)", +"rgba(10 175 10 / 80%)", "rgba(10, 175, 10, 0.8)", +"rgba(10/* comment */175/* comment */10/100%)", "rgb(10, 175, 10)", +"rgba(10,/* comment */150,/* comment */50)", "rgb(10, 150, 50)", +"rgba(10.0, 125.0, 75.0)", "rgb(10, 125, 75)", +"rgba(10%, 45%, 45%)", "rgb(26, 115, 115)", +"rgba(10/* comment */75/* comment */125)", "rgb(10, 75, 125)", +"rgba(10.0, 50.0, 150.0)", "rgb(10, 50, 150)", +"rgb(10, 175, 10, 0.2)", "rgba(10, 175, 10, 0.2)", +"rgb(10, 175, 10, 0.4)", "rgba(10, 175, 10, 0.4)", +"rgb(10, 175, 10, 0.6)", "rgba(10, 175, 10, 0.6)", +"rgb(10%, 70%, 10%, 0.8)", "rgba(26, 179, 26, 0.8)", +"rgb(10%, 70%, 10%, 1.0)", "rgb(26, 179, 26)", +"rgba(10, 150, 50)", "rgb(10, 150, 50)", +"rgba(10, 125, 75)", "rgb(10, 125, 75)", +"rgba(10%,40%, 40%)", "rgb(26, 102, 102)", +"rgba(10%, 45%, 50%)", "rgb(26, 115, 128)", +"rgba(10%, 50%, 60%)", "rgb(26, 128, 153)", + +"hsla(120deg, 75%, 50%, 0.4)", "rgba(32, 223, 32, 0.4)", +"hsla(120DEG, 75%, 50%, 0.4)", "rgba(32, 223, 32, 0.4)", +"hsla(120deG, 75%, 50%, 0.4)", "rgba(32, 223, 32, 0.4)", +"hsla(133.33333333grad, 75%, 50%, 0.6)", "rgba(32, 223, 32, 0.6)", +"hsla(2.0943951024rad, 75%, 50%, 0.8)", "rgba(32, 223, 32, 0.8)", +"hsla(0.3333333333turn, 75%, 50%, 1.0)", "rgb(32, 223, 32)", +"hsl(600deg, 75%, 50%)", "rgb(32, 32, 223)", +"hsl(1066.66666666grad, 75%, 50%)", "rgb(32, 32, 223)", +"hsl(10.4719755118rad, 75%, 50%)", "rgb(32, 32, 223)", +"hsl(2.6666666666turn, 75%, 50%)", "rgb(32, 32, 223)", + +"rgb(-2147483649, 4294967298, -18446744073709551619) /* https://github.com/w3c/web-platform-tests/blob/master/2dcontext/fill-and-stroke-styles/2d.fillStyle.parse.rgb-clamp-3.html */", +"rgb(0, 255, 0)", + +"cmyk(0, 0, 0, 0)", null +]
diff --git a/src/css-parsing-tests/color3_hsl.json b/src/css-parsing-tests/color3_hsl.json new file mode 100644 index 0000000..8e55ac6 --- /dev/null +++ b/src/css-parsing-tests/color3_hsl.json
@@ -0,0 +1,15554 @@ +[ +"hsl(0, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 0%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 25%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 50%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 75%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(30, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(60, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(90, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(120, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(150, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(180, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(210, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(240, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(270, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(300, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(330, 100%, 0%)", "rgb(0, 0, 0)", +"hsl(0, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(30, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(60, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(90, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(120, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(150, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(180, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(210, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(240, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(270, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(300, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(330, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsl(0, 12.5%, 12.5%)", "rgb(36, 28, 28)", +"hsl(30, 12.5%, 12.5%)", "rgb(36, 32, 28)", +"hsl(60, 12.5%, 12.5%)", "rgb(36, 36, 28)", +"hsl(90, 12.5%, 12.5%)", "rgb(32, 36, 28)", +"hsl(120, 12.5%, 12.5%)", "rgb(28, 36, 28)", +"hsl(150, 12.5%, 12.5%)", "rgb(28, 36, 32)", +"hsl(180, 12.5%, 12.5%)", "rgb(28, 36, 36)", +"hsl(210, 12.5%, 12.5%)", "rgb(28, 32, 36)", +"hsl(240, 12.5%, 12.5%)", "rgb(28, 28, 36)", +"hsl(270, 12.5%, 12.5%)", "rgb(32, 28, 36)", +"hsl(300, 12.5%, 12.5%)", "rgb(36, 28, 36)", +"hsl(330, 12.5%, 12.5%)", "rgb(36, 28, 32)", +"hsl(0, 25%, 12.5%)", "rgb(40, 24, 24)", +"hsl(30, 25%, 12.5%)", "rgb(40, 32, 24)", +"hsl(60, 25%, 12.5%)", "rgb(40, 40, 24)", +"hsl(90, 25%, 12.5%)", "rgb(32, 40, 24)", +"hsl(120, 25%, 12.5%)", "rgb(24, 40, 24)", +"hsl(150, 25%, 12.5%)", "rgb(24, 40, 32)", +"hsl(180, 25%, 12.5%)", "rgb(24, 40, 40)", +"hsl(210, 25%, 12.5%)", "rgb(24, 32, 40)", +"hsl(240, 25%, 12.5%)", "rgb(24, 24, 40)", +"hsl(270, 25%, 12.5%)", "rgb(32, 24, 40)", +"hsl(300, 25%, 12.5%)", "rgb(40, 24, 40)", +"hsl(330, 25%, 12.5%)", "rgb(40, 24, 32)", +"hsl(0, 37.5%, 12.5%)", "rgb(44, 20, 20)", +"hsl(30, 37.5%, 12.5%)", "rgb(44, 32, 20)", +"hsl(60, 37.5%, 12.5%)", "rgb(44, 44, 20)", +"hsl(90, 37.5%, 12.5%)", "rgb(32, 44, 20)", +"hsl(120, 37.5%, 12.5%)", "rgb(20, 44, 20)", +"hsl(150, 37.5%, 12.5%)", "rgb(20, 44, 32)", +"hsl(180, 37.5%, 12.5%)", "rgb(20, 44, 44)", +"hsl(210, 37.5%, 12.5%)", "rgb(20, 32, 44)", +"hsl(240, 37.5%, 12.5%)", "rgb(20, 20, 44)", +"hsl(270, 37.5%, 12.5%)", "rgb(32, 20, 44)", +"hsl(300, 37.5%, 12.5%)", "rgb(44, 20, 44)", +"hsl(330, 37.5%, 12.5%)", "rgb(44, 20, 32)", +"hsl(0, 50%, 12.5%)", "rgb(48, 16, 16)", +"hsl(30, 50%, 12.5%)", "rgb(48, 32, 16)", +"hsl(60, 50%, 12.5%)", "rgb(48, 48, 16)", +"hsl(90, 50%, 12.5%)", "rgb(32, 48, 16)", +"hsl(120, 50%, 12.5%)", "rgb(16, 48, 16)", +"hsl(150, 50%, 12.5%)", "rgb(16, 48, 32)", +"hsl(180, 50%, 12.5%)", "rgb(16, 48, 48)", +"hsl(210, 50%, 12.5%)", "rgb(16, 32, 48)", +"hsl(240, 50%, 12.5%)", "rgb(16, 16, 48)", +"hsl(270, 50%, 12.5%)", "rgb(32, 16, 48)", +"hsl(300, 50%, 12.5%)", "rgb(48, 16, 48)", +"hsl(330, 50%, 12.5%)", "rgb(48, 16, 32)", +"hsl(0, 62.5%, 12.5%)", "rgb(52, 12, 12)", +"hsl(30, 62.5%, 12.5%)", "rgb(52, 32, 12)", +"hsl(60, 62.5%, 12.5%)", "rgb(52, 52, 12)", +"hsl(90, 62.5%, 12.5%)", "rgb(32, 52, 12)", +"hsl(120, 62.5%, 12.5%)", "rgb(12, 52, 12)", +"hsl(150, 62.5%, 12.5%)", "rgb(12, 52, 32)", +"hsl(180, 62.5%, 12.5%)", "rgb(12, 52, 52)", +"hsl(210, 62.5%, 12.5%)", "rgb(12, 32, 52)", +"hsl(240, 62.5%, 12.5%)", "rgb(12, 12, 52)", +"hsl(270, 62.5%, 12.5%)", "rgb(32, 12, 52)", +"hsl(300, 62.5%, 12.5%)", "rgb(52, 12, 52)", +"hsl(330, 62.5%, 12.5%)", "rgb(52, 12, 32)", +"hsl(0, 75%, 12.5%)", "rgb(56, 8, 8)", +"hsl(30, 75%, 12.5%)", "rgb(56, 32, 8)", +"hsl(60, 75%, 12.5%)", "rgb(56, 56, 8)", +"hsl(90, 75%, 12.5%)", "rgb(32, 56, 8)", +"hsl(120, 75%, 12.5%)", "rgb(8, 56, 8)", +"hsl(150, 75%, 12.5%)", "rgb(8, 56, 32)", +"hsl(180, 75%, 12.5%)", "rgb(8, 56, 56)", +"hsl(210, 75%, 12.5%)", "rgb(8, 32, 56)", +"hsl(240, 75%, 12.5%)", "rgb(8, 8, 56)", +"hsl(270, 75%, 12.5%)", "rgb(32, 8, 56)", +"hsl(300, 75%, 12.5%)", "rgb(56, 8, 56)", +"hsl(330, 75%, 12.5%)", "rgb(56, 8, 32)", +"hsl(0, 87.5%, 12.5%)", "rgb(60, 4, 4)", +"hsl(30, 87.5%, 12.5%)", "rgb(60, 32, 4)", +"hsl(60, 87.5%, 12.5%)", "rgb(60, 60, 4)", +"hsl(90, 87.5%, 12.5%)", "rgb(32, 60, 4)", +"hsl(120, 87.5%, 12.5%)", "rgb(4, 60, 4)", +"hsl(150, 87.5%, 12.5%)", "rgb(4, 60, 32)", +"hsl(180, 87.5%, 12.5%)", "rgb(4, 60, 60)", +"hsl(210, 87.5%, 12.5%)", "rgb(4, 32, 60)", +"hsl(240, 87.5%, 12.5%)", "rgb(4, 4, 60)", +"hsl(270, 87.5%, 12.5%)", "rgb(32, 4, 60)", +"hsl(300, 87.5%, 12.5%)", "rgb(60, 4, 60)", +"hsl(330, 87.5%, 12.5%)", "rgb(60, 4, 32)", +"hsl(0, 100%, 12.5%)", "rgb(64, 0, 0)", +"hsl(30, 100%, 12.5%)", "rgb(64, 32, 0)", +"hsl(60, 100%, 12.5%)", "rgb(64, 64, 0)", +"hsl(90, 100%, 12.5%)", "rgb(32, 64, 0)", +"hsl(120, 100%, 12.5%)", "rgb(0, 64, 0)", +"hsl(150, 100%, 12.5%)", "rgb(0, 64, 32)", +"hsl(180, 100%, 12.5%)", "rgb(0, 64, 64)", +"hsl(210, 100%, 12.5%)", "rgb(0, 32, 64)", +"hsl(240, 100%, 12.5%)", "rgb(0, 0, 64)", +"hsl(270, 100%, 12.5%)", "rgb(32, 0, 64)", +"hsl(300, 100%, 12.5%)", "rgb(64, 0, 64)", +"hsl(330, 100%, 12.5%)", "rgb(64, 0, 32)", +"hsl(0, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(30, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(60, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(90, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(120, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(150, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(180, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(210, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(240, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(270, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(300, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(330, 0%, 25%)", "rgb(64, 64, 64)", +"hsl(0, 12.5%, 25%)", "rgb(72, 56, 56)", +"hsl(30, 12.5%, 25%)", "rgb(72, 64, 56)", +"hsl(60, 12.5%, 25%)", "rgb(72, 72, 56)", +"hsl(90, 12.5%, 25%)", "rgb(64, 72, 56)", +"hsl(120, 12.5%, 25%)", "rgb(56, 72, 56)", +"hsl(150, 12.5%, 25%)", "rgb(56, 72, 64)", +"hsl(180, 12.5%, 25%)", "rgb(56, 72, 72)", +"hsl(210, 12.5%, 25%)", "rgb(56, 64, 72)", +"hsl(240, 12.5%, 25%)", "rgb(56, 56, 72)", +"hsl(270, 12.5%, 25%)", "rgb(64, 56, 72)", +"hsl(300, 12.5%, 25%)", "rgb(72, 56, 72)", +"hsl(330, 12.5%, 25%)", "rgb(72, 56, 64)", +"hsl(0, 25%, 25%)", "rgb(80, 48, 48)", +"hsl(30, 25%, 25%)", "rgb(80, 64, 48)", +"hsl(60, 25%, 25%)", "rgb(80, 80, 48)", +"hsl(90, 25%, 25%)", "rgb(64, 80, 48)", +"hsl(120, 25%, 25%)", "rgb(48, 80, 48)", +"hsl(150, 25%, 25%)", "rgb(48, 80, 64)", +"hsl(180, 25%, 25%)", "rgb(48, 80, 80)", +"hsl(210, 25%, 25%)", "rgb(48, 64, 80)", +"hsl(240, 25%, 25%)", "rgb(48, 48, 80)", +"hsl(270, 25%, 25%)", "rgb(64, 48, 80)", +"hsl(300, 25%, 25%)", "rgb(80, 48, 80)", +"hsl(330, 25%, 25%)", "rgb(80, 48, 64)", +"hsl(0, 37.5%, 25%)", "rgb(88, 40, 40)", +"hsl(30, 37.5%, 25%)", "rgb(88, 64, 40)", +"hsl(60, 37.5%, 25%)", "rgb(88, 88, 40)", +"hsl(90, 37.5%, 25%)", "rgb(64, 88, 40)", +"hsl(120, 37.5%, 25%)", "rgb(40, 88, 40)", +"hsl(150, 37.5%, 25%)", "rgb(40, 88, 64)", +"hsl(180, 37.5%, 25%)", "rgb(40, 88, 88)", +"hsl(210, 37.5%, 25%)", "rgb(40, 64, 88)", +"hsl(240, 37.5%, 25%)", "rgb(40, 40, 88)", +"hsl(270, 37.5%, 25%)", "rgb(64, 40, 88)", +"hsl(300, 37.5%, 25%)", "rgb(88, 40, 88)", +"hsl(330, 37.5%, 25%)", "rgb(88, 40, 64)", +"hsl(0, 50%, 25%)", "rgb(96, 32, 32)", +"hsl(30, 50%, 25%)", "rgb(96, 64, 32)", +"hsl(60, 50%, 25%)", "rgb(96, 96, 32)", +"hsl(90, 50%, 25%)", "rgb(64, 96, 32)", +"hsl(120, 50%, 25%)", "rgb(32, 96, 32)", +"hsl(150, 50%, 25%)", "rgb(32, 96, 64)", +"hsl(180, 50%, 25%)", "rgb(32, 96, 96)", +"hsl(210, 50%, 25%)", "rgb(32, 64, 96)", +"hsl(240, 50%, 25%)", "rgb(32, 32, 96)", +"hsl(270, 50%, 25%)", "rgb(64, 32, 96)", +"hsl(300, 50%, 25%)", "rgb(96, 32, 96)", +"hsl(330, 50%, 25%)", "rgb(96, 32, 64)", +"hsl(0, 62.5%, 25%)", "rgb(104, 24, 24)", +"hsl(30, 62.5%, 25%)", "rgb(104, 64, 24)", +"hsl(60, 62.5%, 25%)", "rgb(104, 104, 24)", +"hsl(90, 62.5%, 25%)", "rgb(64, 104, 24)", +"hsl(120, 62.5%, 25%)", "rgb(24, 104, 24)", +"hsl(150, 62.5%, 25%)", "rgb(24, 104, 64)", +"hsl(180, 62.5%, 25%)", "rgb(24, 104, 104)", +"hsl(210, 62.5%, 25%)", "rgb(24, 64, 104)", +"hsl(240, 62.5%, 25%)", "rgb(24, 24, 104)", +"hsl(270, 62.5%, 25%)", "rgb(64, 24, 104)", +"hsl(300, 62.5%, 25%)", "rgb(104, 24, 104)", +"hsl(330, 62.5%, 25%)", "rgb(104, 24, 64)", +"hsl(0, 75%, 25%)", "rgb(112, 16, 16)", +"hsl(30, 75%, 25%)", "rgb(112, 64, 16)", +"hsl(60, 75%, 25%)", "rgb(112, 112, 16)", +"hsl(90, 75%, 25%)", "rgb(64, 112, 16)", +"hsl(120, 75%, 25%)", "rgb(16, 112, 16)", +"hsl(150, 75%, 25%)", "rgb(16, 112, 64)", +"hsl(180, 75%, 25%)", "rgb(16, 112, 112)", +"hsl(210, 75%, 25%)", "rgb(16, 64, 112)", +"hsl(240, 75%, 25%)", "rgb(16, 16, 112)", +"hsl(270, 75%, 25%)", "rgb(64, 16, 112)", +"hsl(300, 75%, 25%)", "rgb(112, 16, 112)", +"hsl(330, 75%, 25%)", "rgb(112, 16, 64)", +"hsl(0, 87.5%, 25%)", "rgb(120, 8, 8)", +"hsl(30, 87.5%, 25%)", "rgb(120, 64, 8)", +"hsl(60, 87.5%, 25%)", "rgb(120, 120, 8)", +"hsl(90, 87.5%, 25%)", "rgb(64, 120, 8)", +"hsl(120, 87.5%, 25%)", "rgb(8, 120, 8)", +"hsl(150, 87.5%, 25%)", "rgb(8, 120, 64)", +"hsl(180, 87.5%, 25%)", "rgb(8, 120, 120)", +"hsl(210, 87.5%, 25%)", "rgb(8, 64, 120)", +"hsl(240, 87.5%, 25%)", "rgb(8, 8, 120)", +"hsl(270, 87.5%, 25%)", "rgb(64, 8, 120)", +"hsl(300, 87.5%, 25%)", "rgb(120, 8, 120)", +"hsl(330, 87.5%, 25%)", "rgb(120, 8, 64)", +"hsl(0, 100%, 25%)", "rgb(128, 0, 0)", +"hsl(30, 100%, 25%)", "rgb(128, 64, 0)", +"hsl(60, 100%, 25%)", "rgb(128, 128, 0)", +"hsl(90, 100%, 25%)", "rgb(64, 128, 0)", +"hsl(120, 100%, 25%)", "rgb(0, 128, 0)", +"hsl(150, 100%, 25%)", "rgb(0, 128, 64)", +"hsl(180, 100%, 25%)", "rgb(0, 128, 128)", +"hsl(210, 100%, 25%)", "rgb(0, 64, 128)", +"hsl(240, 100%, 25%)", "rgb(0, 0, 128)", +"hsl(270, 100%, 25%)", "rgb(64, 0, 128)", +"hsl(300, 100%, 25%)", "rgb(128, 0, 128)", +"hsl(330, 100%, 25%)", "rgb(128, 0, 64)", +"hsl(0, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(30, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(60, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(90, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(120, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(150, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(180, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(210, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(240, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(270, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(300, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(330, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsl(0, 12.5%, 37.5%)", "rgb(108, 84, 84)", +"hsl(30, 12.5%, 37.5%)", "rgb(108, 96, 84)", +"hsl(60, 12.5%, 37.5%)", "rgb(108, 108, 84)", +"hsl(90, 12.5%, 37.5%)", "rgb(96, 108, 84)", +"hsl(120, 12.5%, 37.5%)", "rgb(84, 108, 84)", +"hsl(150, 12.5%, 37.5%)", "rgb(84, 108, 96)", +"hsl(180, 12.5%, 37.5%)", "rgb(84, 108, 108)", +"hsl(210, 12.5%, 37.5%)", "rgb(84, 96, 108)", +"hsl(240, 12.5%, 37.5%)", "rgb(84, 84, 108)", +"hsl(270, 12.5%, 37.5%)", "rgb(96, 84, 108)", +"hsl(300, 12.5%, 37.5%)", "rgb(108, 84, 108)", +"hsl(330, 12.5%, 37.5%)", "rgb(108, 84, 96)", +"hsl(0, 25%, 37.5%)", "rgb(120, 72, 72)", +"hsl(30, 25%, 37.5%)", "rgb(120, 96, 72)", +"hsl(60, 25%, 37.5%)", "rgb(120, 120, 72)", +"hsl(90, 25%, 37.5%)", "rgb(96, 120, 72)", +"hsl(120, 25%, 37.5%)", "rgb(72, 120, 72)", +"hsl(150, 25%, 37.5%)", "rgb(72, 120, 96)", +"hsl(180, 25%, 37.5%)", "rgb(72, 120, 120)", +"hsl(210, 25%, 37.5%)", "rgb(72, 96, 120)", +"hsl(240, 25%, 37.5%)", "rgb(72, 72, 120)", +"hsl(270, 25%, 37.5%)", "rgb(96, 72, 120)", +"hsl(300, 25%, 37.5%)", "rgb(120, 72, 120)", +"hsl(330, 25%, 37.5%)", "rgb(120, 72, 96)", +"hsl(0, 37.5%, 37.5%)", "rgb(131, 60, 60)", +"hsl(30, 37.5%, 37.5%)", "rgb(131, 96, 60)", +"hsl(60, 37.5%, 37.5%)", "rgb(131, 131, 60)", +"hsl(90, 37.5%, 37.5%)", "rgb(96, 131, 60)", +"hsl(120, 37.5%, 37.5%)", "rgb(60, 131, 60)", +"hsl(150, 37.5%, 37.5%)", "rgb(60, 131, 96)", +"hsl(180, 37.5%, 37.5%)", "rgb(60, 131, 131)", +"hsl(210, 37.5%, 37.5%)", "rgb(60, 96, 131)", +"hsl(240, 37.5%, 37.5%)", "rgb(60, 60, 131)", +"hsl(270, 37.5%, 37.5%)", "rgb(96, 60, 131)", +"hsl(300, 37.5%, 37.5%)", "rgb(131, 60, 131)", +"hsl(330, 37.5%, 37.5%)", "rgb(131, 60, 96)", +"hsl(0, 50%, 37.5%)", "rgb(143, 48, 48)", +"hsl(30, 50%, 37.5%)", "rgb(143, 96, 48)", +"hsl(60, 50%, 37.5%)", "rgb(143, 143, 48)", +"hsl(90, 50%, 37.5%)", "rgb(96, 143, 48)", +"hsl(120, 50%, 37.5%)", "rgb(48, 143, 48)", +"hsl(150, 50%, 37.5%)", "rgb(48, 143, 96)", +"hsl(180, 50%, 37.5%)", "rgb(48, 143, 143)", +"hsl(210, 50%, 37.5%)", "rgb(48, 96, 143)", +"hsl(240, 50%, 37.5%)", "rgb(48, 48, 143)", +"hsl(270, 50%, 37.5%)", "rgb(96, 48, 143)", +"hsl(300, 50%, 37.5%)", "rgb(143, 48, 143)", +"hsl(330, 50%, 37.5%)", "rgb(143, 48, 96)", +"hsl(0, 62.5%, 37.5%)", "rgb(155, 36, 36)", +"hsl(30, 62.5%, 37.5%)", "rgb(155, 96, 36)", +"hsl(60, 62.5%, 37.5%)", "rgb(155, 155, 36)", +"hsl(90, 62.5%, 37.5%)", "rgb(96, 155, 36)", +"hsl(120, 62.5%, 37.5%)", "rgb(36, 155, 36)", +"hsl(150, 62.5%, 37.5%)", "rgb(36, 155, 96)", +"hsl(180, 62.5%, 37.5%)", "rgb(36, 155, 155)", +"hsl(210, 62.5%, 37.5%)", "rgb(36, 96, 155)", +"hsl(240, 62.5%, 37.5%)", "rgb(36, 36, 155)", +"hsl(270, 62.5%, 37.5%)", "rgb(96, 36, 155)", +"hsl(300, 62.5%, 37.5%)", "rgb(155, 36, 155)", +"hsl(330, 62.5%, 37.5%)", "rgb(155, 36, 96)", +"hsl(0, 75%, 37.5%)", "rgb(167, 24, 24)", +"hsl(30, 75%, 37.5%)", "rgb(167, 96, 24)", +"hsl(60, 75%, 37.5%)", "rgb(167, 167, 24)", +"hsl(90, 75%, 37.5%)", "rgb(96, 167, 24)", +"hsl(120, 75%, 37.5%)", "rgb(24, 167, 24)", +"hsl(150, 75%, 37.5%)", "rgb(24, 167, 96)", +"hsl(180, 75%, 37.5%)", "rgb(24, 167, 167)", +"hsl(210, 75%, 37.5%)", "rgb(24, 96, 167)", +"hsl(240, 75%, 37.5%)", "rgb(24, 24, 167)", +"hsl(270, 75%, 37.5%)", "rgb(96, 24, 167)", +"hsl(300, 75%, 37.5%)", "rgb(167, 24, 167)", +"hsl(330, 75%, 37.5%)", "rgb(167, 24, 96)", +"hsl(0, 87.5%, 37.5%)", "rgb(179, 12, 12)", +"hsl(30, 87.5%, 37.5%)", "rgb(179, 96, 12)", +"hsl(60, 87.5%, 37.5%)", "rgb(179, 179, 12)", +"hsl(90, 87.5%, 37.5%)", "rgb(96, 179, 12)", +"hsl(120, 87.5%, 37.5%)", "rgb(12, 179, 12)", +"hsl(150, 87.5%, 37.5%)", "rgb(12, 179, 96)", +"hsl(180, 87.5%, 37.5%)", "rgb(12, 179, 179)", +"hsl(210, 87.5%, 37.5%)", "rgb(12, 96, 179)", +"hsl(240, 87.5%, 37.5%)", "rgb(12, 12, 179)", +"hsl(270, 87.5%, 37.5%)", "rgb(96, 12, 179)", +"hsl(300, 87.5%, 37.5%)", "rgb(179, 12, 179)", +"hsl(330, 87.5%, 37.5%)", "rgb(179, 12, 96)", +"hsl(0, 100%, 37.5%)", "rgb(191, 0, 0)", +"hsl(30, 100%, 37.5%)", "rgb(191, 96, 0)", +"hsl(60, 100%, 37.5%)", "rgb(191, 191, 0)", +"hsl(90, 100%, 37.5%)", "rgb(96, 191, 0)", +"hsl(120, 100%, 37.5%)", "rgb(0, 191, 0)", +"hsl(150, 100%, 37.5%)", "rgb(0, 191, 96)", +"hsl(180, 100%, 37.5%)", "rgb(0, 191, 191)", +"hsl(210, 100%, 37.5%)", "rgb(0, 96, 191)", +"hsl(240, 100%, 37.5%)", "rgb(0, 0, 191)", +"hsl(270, 100%, 37.5%)", "rgb(96, 0, 191)", +"hsl(300, 100%, 37.5%)", "rgb(191, 0, 191)", +"hsl(330, 100%, 37.5%)", "rgb(191, 0, 96)", +"hsl(0, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(30, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(60, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(90, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(120, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(150, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(180, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(210, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(240, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(270, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(300, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(330, 0%, 50%)", "rgb(128, 128, 128)", +"hsl(0, 12.5%, 50%)", "rgb(143, 112, 112)", +"hsl(30, 12.5%, 50%)", "rgb(143, 128, 112)", +"hsl(60, 12.5%, 50%)", "rgb(143, 143, 112)", +"hsl(90, 12.5%, 50%)", "rgb(128, 143, 112)", +"hsl(120, 12.5%, 50%)", "rgb(112, 143, 112)", +"hsl(150, 12.5%, 50%)", "rgb(112, 143, 128)", +"hsl(180, 12.5%, 50%)", "rgb(112, 143, 143)", +"hsl(210, 12.5%, 50%)", "rgb(112, 128, 143)", +"hsl(240, 12.5%, 50%)", "rgb(112, 112, 143)", +"hsl(270, 12.5%, 50%)", "rgb(128, 112, 143)", +"hsl(300, 12.5%, 50%)", "rgb(143, 112, 143)", +"hsl(330, 12.5%, 50%)", "rgb(143, 112, 128)", +"hsl(0, 25%, 50%)", "rgb(159, 96, 96)", +"hsl(30, 25%, 50%)", "rgb(159, 128, 96)", +"hsl(60, 25%, 50%)", "rgb(159, 159, 96)", +"hsl(90, 25%, 50%)", "rgb(128, 159, 96)", +"hsl(120, 25%, 50%)", "rgb(96, 159, 96)", +"hsl(150, 25%, 50%)", "rgb(96, 159, 128)", +"hsl(180, 25%, 50%)", "rgb(96, 159, 159)", +"hsl(210, 25%, 50%)", "rgb(96, 128, 159)", +"hsl(240, 25%, 50%)", "rgb(96, 96, 159)", +"hsl(270, 25%, 50%)", "rgb(128, 96, 159)", +"hsl(300, 25%, 50%)", "rgb(159, 96, 159)", +"hsl(330, 25%, 50%)", "rgb(159, 96, 128)", +"hsl(0, 37.5%, 50%)", "rgb(175, 80, 80)", +"hsl(30, 37.5%, 50%)", "rgb(175, 128, 80)", +"hsl(60, 37.5%, 50%)", "rgb(175, 175, 80)", +"hsl(90, 37.5%, 50%)", "rgb(128, 175, 80)", +"hsl(120, 37.5%, 50%)", "rgb(80, 175, 80)", +"hsl(150, 37.5%, 50%)", "rgb(80, 175, 128)", +"hsl(180, 37.5%, 50%)", "rgb(80, 175, 175)", +"hsl(210, 37.5%, 50%)", "rgb(80, 128, 175)", +"hsl(240, 37.5%, 50%)", "rgb(80, 80, 175)", +"hsl(270, 37.5%, 50%)", "rgb(128, 80, 175)", +"hsl(300, 37.5%, 50%)", "rgb(175, 80, 175)", +"hsl(330, 37.5%, 50%)", "rgb(175, 80, 128)", +"hsl(0, 50%, 50%)", "rgb(191, 64, 64)", +"hsl(30, 50%, 50%)", "rgb(191, 128, 64)", +"hsl(60, 50%, 50%)", "rgb(191, 191, 64)", +"hsl(90, 50%, 50%)", "rgb(128, 191, 64)", +"hsl(120, 50%, 50%)", "rgb(64, 191, 64)", +"hsl(150, 50%, 50%)", "rgb(64, 191, 128)", +"hsl(180, 50%, 50%)", "rgb(64, 191, 191)", +"hsl(210, 50%, 50%)", "rgb(64, 128, 191)", +"hsl(240, 50%, 50%)", "rgb(64, 64, 191)", +"hsl(270, 50%, 50%)", "rgb(128, 64, 191)", +"hsl(300, 50%, 50%)", "rgb(191, 64, 191)", +"hsl(330, 50%, 50%)", "rgb(191, 64, 128)", +"hsl(0, 62.5%, 50%)", "rgb(207, 48, 48)", +"hsl(30, 62.5%, 50%)", "rgb(207, 128, 48)", +"hsl(60, 62.5%, 50%)", "rgb(207, 207, 48)", +"hsl(90, 62.5%, 50%)", "rgb(128, 207, 48)", +"hsl(120, 62.5%, 50%)", "rgb(48, 207, 48)", +"hsl(150, 62.5%, 50%)", "rgb(48, 207, 128)", +"hsl(180, 62.5%, 50%)", "rgb(48, 207, 207)", +"hsl(210, 62.5%, 50%)", "rgb(48, 128, 207)", +"hsl(240, 62.5%, 50%)", "rgb(48, 48, 207)", +"hsl(270, 62.5%, 50%)", "rgb(128, 48, 207)", +"hsl(300, 62.5%, 50%)", "rgb(207, 48, 207)", +"hsl(330, 62.5%, 50%)", "rgb(207, 48, 128)", +"hsl(0, 75%, 50%)", "rgb(223, 32, 32)", +"hsl(30, 75%, 50%)", "rgb(223, 128, 32)", +"hsl(60, 75%, 50%)", "rgb(223, 223, 32)", +"hsl(90, 75%, 50%)", "rgb(128, 223, 32)", +"hsl(120, 75%, 50%)", "rgb(32, 223, 32)", +"hsl(150, 75%, 50%)", "rgb(32, 223, 128)", +"hsl(180, 75%, 50%)", "rgb(32, 223, 223)", +"hsl(210, 75%, 50%)", "rgb(32, 128, 223)", +"hsl(240, 75%, 50%)", "rgb(32, 32, 223)", +"hsl(270, 75%, 50%)", "rgb(128, 32, 223)", +"hsl(300, 75%, 50%)", "rgb(223, 32, 223)", +"hsl(330, 75%, 50%)", "rgb(223, 32, 128)", +"hsl(0, 87.5%, 50%)", "rgb(239, 16, 16)", +"hsl(30, 87.5%, 50%)", "rgb(239, 128, 16)", +"hsl(60, 87.5%, 50%)", "rgb(239, 239, 16)", +"hsl(90, 87.5%, 50%)", "rgb(128, 239, 16)", +"hsl(120, 87.5%, 50%)", "rgb(16, 239, 16)", +"hsl(150, 87.5%, 50%)", "rgb(16, 239, 128)", +"hsl(180, 87.5%, 50%)", "rgb(16, 239, 239)", +"hsl(210, 87.5%, 50%)", "rgb(16, 128, 239)", +"hsl(240, 87.5%, 50%)", "rgb(16, 16, 239)", +"hsl(270, 87.5%, 50%)", "rgb(128, 16, 239)", +"hsl(300, 87.5%, 50%)", "rgb(239, 16, 239)", +"hsl(330, 87.5%, 50%)", "rgb(239, 16, 128)", +"hsl(0, 100%, 50%)", "rgb(255, 0, 0)", +"hsl(30, 100%, 50%)", "rgb(255, 128, 0)", +"hsl(60, 100%, 50%)", "rgb(255, 255, 0)", +"hsl(90, 100%, 50%)", "rgb(128, 255, 0)", +"hsl(120, 100%, 50%)", "rgb(0, 255, 0)", +"hsl(150, 100%, 50%)", "rgb(0, 255, 128)", +"hsl(180, 100%, 50%)", "rgb(0, 255, 255)", +"hsl(210, 100%, 50%)", "rgb(0, 128, 255)", +"hsl(240, 100%, 50%)", "rgb(0, 0, 255)", +"hsl(270, 100%, 50%)", "rgb(128, 0, 255)", +"hsl(300, 100%, 50%)", "rgb(255, 0, 255)", +"hsl(330, 100%, 50%)", "rgb(255, 0, 128)", +"hsl(0, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(30, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(60, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(90, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(120, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(150, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(180, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(210, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(240, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(270, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(300, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(330, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsl(0, 12.5%, 62.5%)", "rgb(171, 147, 147)", +"hsl(30, 12.5%, 62.5%)", "rgb(171, 159, 147)", +"hsl(60, 12.5%, 62.5%)", "rgb(171, 171, 147)", +"hsl(90, 12.5%, 62.5%)", "rgb(159, 171, 147)", +"hsl(120, 12.5%, 62.5%)", "rgb(147, 171, 147)", +"hsl(150, 12.5%, 62.5%)", "rgb(147, 171, 159)", +"hsl(180, 12.5%, 62.5%)", "rgb(147, 171, 171)", +"hsl(210, 12.5%, 62.5%)", "rgb(147, 159, 171)", +"hsl(240, 12.5%, 62.5%)", "rgb(147, 147, 171)", +"hsl(270, 12.5%, 62.5%)", "rgb(159, 147, 171)", +"hsl(300, 12.5%, 62.5%)", "rgb(171, 147, 171)", +"hsl(330, 12.5%, 62.5%)", "rgb(171, 147, 159)", +"hsl(0, 25%, 62.5%)", "rgb(183, 135, 135)", +"hsl(30, 25%, 62.5%)", "rgb(183, 159, 135)", +"hsl(60, 25%, 62.5%)", "rgb(183, 183, 135)", +"hsl(90, 25%, 62.5%)", "rgb(159, 183, 135)", +"hsl(120, 25%, 62.5%)", "rgb(135, 183, 135)", +"hsl(150, 25%, 62.5%)", "rgb(135, 183, 159)", +"hsl(180, 25%, 62.5%)", "rgb(135, 183, 183)", +"hsl(210, 25%, 62.5%)", "rgb(135, 159, 183)", +"hsl(240, 25%, 62.5%)", "rgb(135, 135, 183)", +"hsl(270, 25%, 62.5%)", "rgb(159, 135, 183)", +"hsl(300, 25%, 62.5%)", "rgb(183, 135, 183)", +"hsl(330, 25%, 62.5%)", "rgb(183, 135, 159)", +"hsl(0, 37.5%, 62.5%)", "rgb(195, 124, 124)", +"hsl(30, 37.5%, 62.5%)", "rgb(195, 159, 124)", +"hsl(60, 37.5%, 62.5%)", "rgb(195, 195, 124)", +"hsl(90, 37.5%, 62.5%)", "rgb(159, 195, 124)", +"hsl(120, 37.5%, 62.5%)", "rgb(124, 195, 124)", +"hsl(150, 37.5%, 62.5%)", "rgb(124, 195, 159)", +"hsl(180, 37.5%, 62.5%)", "rgb(124, 195, 195)", +"hsl(210, 37.5%, 62.5%)", "rgb(124, 159, 195)", +"hsl(240, 37.5%, 62.5%)", "rgb(124, 124, 195)", +"hsl(270, 37.5%, 62.5%)", "rgb(159, 124, 195)", +"hsl(300, 37.5%, 62.5%)", "rgb(195, 124, 195)", +"hsl(330, 37.5%, 62.5%)", "rgb(195, 124, 159)", +"hsl(0, 50%, 62.5%)", "rgb(207, 112, 112)", +"hsl(30, 50%, 62.5%)", "rgb(207, 159, 112)", +"hsl(60, 50%, 62.5%)", "rgb(207, 207, 112)", +"hsl(90, 50%, 62.5%)", "rgb(159, 207, 112)", +"hsl(120, 50%, 62.5%)", "rgb(112, 207, 112)", +"hsl(150, 50%, 62.5%)", "rgb(112, 207, 159)", +"hsl(180, 50%, 62.5%)", "rgb(112, 207, 207)", +"hsl(210, 50%, 62.5%)", "rgb(112, 159, 207)", +"hsl(240, 50%, 62.5%)", "rgb(112, 112, 207)", +"hsl(270, 50%, 62.5%)", "rgb(159, 112, 207)", +"hsl(300, 50%, 62.5%)", "rgb(207, 112, 207)", +"hsl(330, 50%, 62.5%)", "rgb(207, 112, 159)", +"hsl(0, 62.5%, 62.5%)", "rgb(219, 100, 100)", +"hsl(30, 62.5%, 62.5%)", "rgb(219, 159, 100)", +"hsl(60, 62.5%, 62.5%)", "rgb(219, 219, 100)", +"hsl(90, 62.5%, 62.5%)", "rgb(159, 219, 100)", +"hsl(120, 62.5%, 62.5%)", "rgb(100, 219, 100)", +"hsl(150, 62.5%, 62.5%)", "rgb(100, 219, 159)", +"hsl(180, 62.5%, 62.5%)", "rgb(100, 219, 219)", +"hsl(210, 62.5%, 62.5%)", "rgb(100, 159, 219)", +"hsl(240, 62.5%, 62.5%)", "rgb(100, 100, 219)", +"hsl(270, 62.5%, 62.5%)", "rgb(159, 100, 219)", +"hsl(300, 62.5%, 62.5%)", "rgb(219, 100, 219)", +"hsl(330, 62.5%, 62.5%)", "rgb(219, 100, 159)", +"hsl(0, 75%, 62.5%)", "rgb(231, 88, 88)", +"hsl(30, 75%, 62.5%)", "rgb(231, 159, 88)", +"hsl(60, 75%, 62.5%)", "rgb(231, 231, 88)", +"hsl(90, 75%, 62.5%)", "rgb(159, 231, 88)", +"hsl(120, 75%, 62.5%)", "rgb(88, 231, 88)", +"hsl(150, 75%, 62.5%)", "rgb(88, 231, 159)", +"hsl(180, 75%, 62.5%)", "rgb(88, 231, 231)", +"hsl(210, 75%, 62.5%)", "rgb(88, 159, 231)", +"hsl(240, 75%, 62.5%)", "rgb(88, 88, 231)", +"hsl(270, 75%, 62.5%)", "rgb(159, 88, 231)", +"hsl(300, 75%, 62.5%)", "rgb(231, 88, 231)", +"hsl(330, 75%, 62.5%)", "rgb(231, 88, 159)", +"hsl(0, 87.5%, 62.5%)", "rgb(243, 76, 76)", +"hsl(30, 87.5%, 62.5%)", "rgb(243, 159, 76)", +"hsl(60, 87.5%, 62.5%)", "rgb(243, 243, 76)", +"hsl(90, 87.5%, 62.5%)", "rgb(159, 243, 76)", +"hsl(120, 87.5%, 62.5%)", "rgb(76, 243, 76)", +"hsl(150, 87.5%, 62.5%)", "rgb(76, 243, 159)", +"hsl(180, 87.5%, 62.5%)", "rgb(76, 243, 243)", +"hsl(210, 87.5%, 62.5%)", "rgb(76, 159, 243)", +"hsl(240, 87.5%, 62.5%)", "rgb(76, 76, 243)", +"hsl(270, 87.5%, 62.5%)", "rgb(159, 76, 243)", +"hsl(300, 87.5%, 62.5%)", "rgb(243, 76, 243)", +"hsl(330, 87.5%, 62.5%)", "rgb(243, 76, 159)", +"hsl(0, 100%, 62.5%)", "rgb(255, 64, 64)", +"hsl(30, 100%, 62.5%)", "rgb(255, 159, 64)", +"hsl(60, 100%, 62.5%)", "rgb(255, 255, 64)", +"hsl(90, 100%, 62.5%)", "rgb(159, 255, 64)", +"hsl(120, 100%, 62.5%)", "rgb(64, 255, 64)", +"hsl(150, 100%, 62.5%)", "rgb(64, 255, 159)", +"hsl(180, 100%, 62.5%)", "rgb(64, 255, 255)", +"hsl(210, 100%, 62.5%)", "rgb(64, 159, 255)", +"hsl(240, 100%, 62.5%)", "rgb(64, 64, 255)", +"hsl(270, 100%, 62.5%)", "rgb(159, 64, 255)", +"hsl(300, 100%, 62.5%)", "rgb(255, 64, 255)", +"hsl(330, 100%, 62.5%)", "rgb(255, 64, 159)", +"hsl(0, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(30, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(60, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(90, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(120, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(150, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(180, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(210, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(240, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(270, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(300, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(330, 0%, 75%)", "rgb(191, 191, 191)", +"hsl(0, 12.5%, 75%)", "rgb(199, 183, 183)", +"hsl(30, 12.5%, 75%)", "rgb(199, 191, 183)", +"hsl(60, 12.5%, 75%)", "rgb(199, 199, 183)", +"hsl(90, 12.5%, 75%)", "rgb(191, 199, 183)", +"hsl(120, 12.5%, 75%)", "rgb(183, 199, 183)", +"hsl(150, 12.5%, 75%)", "rgb(183, 199, 191)", +"hsl(180, 12.5%, 75%)", "rgb(183, 199, 199)", +"hsl(210, 12.5%, 75%)", "rgb(183, 191, 199)", +"hsl(240, 12.5%, 75%)", "rgb(183, 183, 199)", +"hsl(270, 12.5%, 75%)", "rgb(191, 183, 199)", +"hsl(300, 12.5%, 75%)", "rgb(199, 183, 199)", +"hsl(330, 12.5%, 75%)", "rgb(199, 183, 191)", +"hsl(0, 25%, 75%)", "rgb(207, 175, 175)", +"hsl(30, 25%, 75%)", "rgb(207, 191, 175)", +"hsl(60, 25%, 75%)", "rgb(207, 207, 175)", +"hsl(90, 25%, 75%)", "rgb(191, 207, 175)", +"hsl(120, 25%, 75%)", "rgb(175, 207, 175)", +"hsl(150, 25%, 75%)", "rgb(175, 207, 191)", +"hsl(180, 25%, 75%)", "rgb(175, 207, 207)", +"hsl(210, 25%, 75%)", "rgb(175, 191, 207)", +"hsl(240, 25%, 75%)", "rgb(175, 175, 207)", +"hsl(270, 25%, 75%)", "rgb(191, 175, 207)", +"hsl(300, 25%, 75%)", "rgb(207, 175, 207)", +"hsl(330, 25%, 75%)", "rgb(207, 175, 191)", +"hsl(0, 37.5%, 75%)", "rgb(215, 167, 167)", +"hsl(30, 37.5%, 75%)", "rgb(215, 191, 167)", +"hsl(60, 37.5%, 75%)", "rgb(215, 215, 167)", +"hsl(90, 37.5%, 75%)", "rgb(191, 215, 167)", +"hsl(120, 37.5%, 75%)", "rgb(167, 215, 167)", +"hsl(150, 37.5%, 75%)", "rgb(167, 215, 191)", +"hsl(180, 37.5%, 75%)", "rgb(167, 215, 215)", +"hsl(210, 37.5%, 75%)", "rgb(167, 191, 215)", +"hsl(240, 37.5%, 75%)", "rgb(167, 167, 215)", +"hsl(270, 37.5%, 75%)", "rgb(191, 167, 215)", +"hsl(300, 37.5%, 75%)", "rgb(215, 167, 215)", +"hsl(330, 37.5%, 75%)", "rgb(215, 167, 191)", +"hsl(0, 50%, 75%)", "rgb(223, 159, 159)", +"hsl(30, 50%, 75%)", "rgb(223, 191, 159)", +"hsl(60, 50%, 75%)", "rgb(223, 223, 159)", +"hsl(90, 50%, 75%)", "rgb(191, 223, 159)", +"hsl(120, 50%, 75%)", "rgb(159, 223, 159)", +"hsl(150, 50%, 75%)", "rgb(159, 223, 191)", +"hsl(180, 50%, 75%)", "rgb(159, 223, 223)", +"hsl(210, 50%, 75%)", "rgb(159, 191, 223)", +"hsl(240, 50%, 75%)", "rgb(159, 159, 223)", +"hsl(270, 50%, 75%)", "rgb(191, 159, 223)", +"hsl(300, 50%, 75%)", "rgb(223, 159, 223)", +"hsl(330, 50%, 75%)", "rgb(223, 159, 191)", +"hsl(0, 62.5%, 75%)", "rgb(231, 151, 151)", +"hsl(30, 62.5%, 75%)", "rgb(231, 191, 151)", +"hsl(60, 62.5%, 75%)", "rgb(231, 231, 151)", +"hsl(90, 62.5%, 75%)", "rgb(191, 231, 151)", +"hsl(120, 62.5%, 75%)", "rgb(151, 231, 151)", +"hsl(150, 62.5%, 75%)", "rgb(151, 231, 191)", +"hsl(180, 62.5%, 75%)", "rgb(151, 231, 231)", +"hsl(210, 62.5%, 75%)", "rgb(151, 191, 231)", +"hsl(240, 62.5%, 75%)", "rgb(151, 151, 231)", +"hsl(270, 62.5%, 75%)", "rgb(191, 151, 231)", +"hsl(300, 62.5%, 75%)", "rgb(231, 151, 231)", +"hsl(330, 62.5%, 75%)", "rgb(231, 151, 191)", +"hsl(0, 75%, 75%)", "rgb(239, 143, 143)", +"hsl(30, 75%, 75%)", "rgb(239, 191, 143)", +"hsl(60, 75%, 75%)", "rgb(239, 239, 143)", +"hsl(90, 75%, 75%)", "rgb(191, 239, 143)", +"hsl(120, 75%, 75%)", "rgb(143, 239, 143)", +"hsl(150, 75%, 75%)", "rgb(143, 239, 191)", +"hsl(180, 75%, 75%)", "rgb(143, 239, 239)", +"hsl(210, 75%, 75%)", "rgb(143, 191, 239)", +"hsl(240, 75%, 75%)", "rgb(143, 143, 239)", +"hsl(270, 75%, 75%)", "rgb(191, 143, 239)", +"hsl(300, 75%, 75%)", "rgb(239, 143, 239)", +"hsl(330, 75%, 75%)", "rgb(239, 143, 191)", +"hsl(0, 87.5%, 75%)", "rgb(247, 135, 135)", +"hsl(30, 87.5%, 75%)", "rgb(247, 191, 135)", +"hsl(60, 87.5%, 75%)", "rgb(247, 247, 135)", +"hsl(90, 87.5%, 75%)", "rgb(191, 247, 135)", +"hsl(120, 87.5%, 75%)", "rgb(135, 247, 135)", +"hsl(150, 87.5%, 75%)", "rgb(135, 247, 191)", +"hsl(180, 87.5%, 75%)", "rgb(135, 247, 247)", +"hsl(210, 87.5%, 75%)", "rgb(135, 191, 247)", +"hsl(240, 87.5%, 75%)", "rgb(135, 135, 247)", +"hsl(270, 87.5%, 75%)", "rgb(191, 135, 247)", +"hsl(300, 87.5%, 75%)", "rgb(247, 135, 247)", +"hsl(330, 87.5%, 75%)", "rgb(247, 135, 191)", +"hsl(0, 100%, 75%)", "rgb(255, 128, 128)", +"hsl(30, 100%, 75%)", "rgb(255, 191, 128)", +"hsl(60, 100%, 75%)", "rgb(255, 255, 128)", +"hsl(90, 100%, 75%)", "rgb(191, 255, 128)", +"hsl(120, 100%, 75%)", "rgb(128, 255, 128)", +"hsl(150, 100%, 75%)", "rgb(128, 255, 191)", +"hsl(180, 100%, 75%)", "rgb(128, 255, 255)", +"hsl(210, 100%, 75%)", "rgb(128, 191, 255)", +"hsl(240, 100%, 75%)", "rgb(128, 128, 255)", +"hsl(270, 100%, 75%)", "rgb(191, 128, 255)", +"hsl(300, 100%, 75%)", "rgb(255, 128, 255)", +"hsl(330, 100%, 75%)", "rgb(255, 128, 191)", +"hsl(0, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(30, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(60, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(90, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(120, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(150, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(180, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(210, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(240, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(270, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(300, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(330, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsl(0, 12.5%, 87.5%)", "rgb(227, 219, 219)", +"hsl(30, 12.5%, 87.5%)", "rgb(227, 223, 219)", +"hsl(60, 12.5%, 87.5%)", "rgb(227, 227, 219)", +"hsl(90, 12.5%, 87.5%)", "rgb(223, 227, 219)", +"hsl(120, 12.5%, 87.5%)", "rgb(219, 227, 219)", +"hsl(150, 12.5%, 87.5%)", "rgb(219, 227, 223)", +"hsl(180, 12.5%, 87.5%)", "rgb(219, 227, 227)", +"hsl(210, 12.5%, 87.5%)", "rgb(219, 223, 227)", +"hsl(240, 12.5%, 87.5%)", "rgb(219, 219, 227)", +"hsl(270, 12.5%, 87.5%)", "rgb(223, 219, 227)", +"hsl(300, 12.5%, 87.5%)", "rgb(227, 219, 227)", +"hsl(330, 12.5%, 87.5%)", "rgb(227, 219, 223)", +"hsl(0, 25%, 87.5%)", "rgb(231, 215, 215)", +"hsl(30, 25%, 87.5%)", "rgb(231, 223, 215)", +"hsl(60, 25%, 87.5%)", "rgb(231, 231, 215)", +"hsl(90, 25%, 87.5%)", "rgb(223, 231, 215)", +"hsl(120, 25%, 87.5%)", "rgb(215, 231, 215)", +"hsl(150, 25%, 87.5%)", "rgb(215, 231, 223)", +"hsl(180, 25%, 87.5%)", "rgb(215, 231, 231)", +"hsl(210, 25%, 87.5%)", "rgb(215, 223, 231)", +"hsl(240, 25%, 87.5%)", "rgb(215, 215, 231)", +"hsl(270, 25%, 87.5%)", "rgb(223, 215, 231)", +"hsl(300, 25%, 87.5%)", "rgb(231, 215, 231)", +"hsl(330, 25%, 87.5%)", "rgb(231, 215, 223)", +"hsl(0, 37.5%, 87.5%)", "rgb(235, 211, 211)", +"hsl(30, 37.5%, 87.5%)", "rgb(235, 223, 211)", +"hsl(60, 37.5%, 87.5%)", "rgb(235, 235, 211)", +"hsl(90, 37.5%, 87.5%)", "rgb(223, 235, 211)", +"hsl(120, 37.5%, 87.5%)", "rgb(211, 235, 211)", +"hsl(150, 37.5%, 87.5%)", "rgb(211, 235, 223)", +"hsl(180, 37.5%, 87.5%)", "rgb(211, 235, 235)", +"hsl(210, 37.5%, 87.5%)", "rgb(211, 223, 235)", +"hsl(240, 37.5%, 87.5%)", "rgb(211, 211, 235)", +"hsl(270, 37.5%, 87.5%)", "rgb(223, 211, 235)", +"hsl(300, 37.5%, 87.5%)", "rgb(235, 211, 235)", +"hsl(330, 37.5%, 87.5%)", "rgb(235, 211, 223)", +"hsl(0, 50%, 87.5%)", "rgb(239, 207, 207)", +"hsl(30, 50%, 87.5%)", "rgb(239, 223, 207)", +"hsl(60, 50%, 87.5%)", "rgb(239, 239, 207)", +"hsl(90, 50%, 87.5%)", "rgb(223, 239, 207)", +"hsl(120, 50%, 87.5%)", "rgb(207, 239, 207)", +"hsl(150, 50%, 87.5%)", "rgb(207, 239, 223)", +"hsl(180, 50%, 87.5%)", "rgb(207, 239, 239)", +"hsl(210, 50%, 87.5%)", "rgb(207, 223, 239)", +"hsl(240, 50%, 87.5%)", "rgb(207, 207, 239)", +"hsl(270, 50%, 87.5%)", "rgb(223, 207, 239)", +"hsl(300, 50%, 87.5%)", "rgb(239, 207, 239)", +"hsl(330, 50%, 87.5%)", "rgb(239, 207, 223)", +"hsl(0, 62.5%, 87.5%)", "rgb(243, 203, 203)", +"hsl(30, 62.5%, 87.5%)", "rgb(243, 223, 203)", +"hsl(60, 62.5%, 87.5%)", "rgb(243, 243, 203)", +"hsl(90, 62.5%, 87.5%)", "rgb(223, 243, 203)", +"hsl(120, 62.5%, 87.5%)", "rgb(203, 243, 203)", +"hsl(150, 62.5%, 87.5%)", "rgb(203, 243, 223)", +"hsl(180, 62.5%, 87.5%)", "rgb(203, 243, 243)", +"hsl(210, 62.5%, 87.5%)", "rgb(203, 223, 243)", +"hsl(240, 62.5%, 87.5%)", "rgb(203, 203, 243)", +"hsl(270, 62.5%, 87.5%)", "rgb(223, 203, 243)", +"hsl(300, 62.5%, 87.5%)", "rgb(243, 203, 243)", +"hsl(330, 62.5%, 87.5%)", "rgb(243, 203, 223)", +"hsl(0, 75%, 87.5%)", "rgb(247, 199, 199)", +"hsl(30, 75%, 87.5%)", "rgb(247, 223, 199)", +"hsl(60, 75%, 87.5%)", "rgb(247, 247, 199)", +"hsl(90, 75%, 87.5%)", "rgb(223, 247, 199)", +"hsl(120, 75%, 87.5%)", "rgb(199, 247, 199)", +"hsl(150, 75%, 87.5%)", "rgb(199, 247, 223)", +"hsl(180, 75%, 87.5%)", "rgb(199, 247, 247)", +"hsl(210, 75%, 87.5%)", "rgb(199, 223, 247)", +"hsl(240, 75%, 87.5%)", "rgb(199, 199, 247)", +"hsl(270, 75%, 87.5%)", "rgb(223, 199, 247)", +"hsl(300, 75%, 87.5%)", "rgb(247, 199, 247)", +"hsl(330, 75%, 87.5%)", "rgb(247, 199, 223)", +"hsl(0, 87.5%, 87.5%)", "rgb(251, 195, 195)", +"hsl(30, 87.5%, 87.5%)", "rgb(251, 223, 195)", +"hsl(60, 87.5%, 87.5%)", "rgb(251, 251, 195)", +"hsl(90, 87.5%, 87.5%)", "rgb(223, 251, 195)", +"hsl(120, 87.5%, 87.5%)", "rgb(195, 251, 195)", +"hsl(150, 87.5%, 87.5%)", "rgb(195, 251, 223)", +"hsl(180, 87.5%, 87.5%)", "rgb(195, 251, 251)", +"hsl(210, 87.5%, 87.5%)", "rgb(195, 223, 251)", +"hsl(240, 87.5%, 87.5%)", "rgb(195, 195, 251)", +"hsl(270, 87.5%, 87.5%)", "rgb(223, 195, 251)", +"hsl(300, 87.5%, 87.5%)", "rgb(251, 195, 251)", +"hsl(330, 87.5%, 87.5%)", "rgb(251, 195, 223)", +"hsl(0, 100%, 87.5%)", "rgb(255, 191, 191)", +"hsl(30, 100%, 87.5%)", "rgb(255, 223, 191)", +"hsl(60, 100%, 87.5%)", "rgb(255, 255, 191)", +"hsl(90, 100%, 87.5%)", "rgb(223, 255, 191)", +"hsl(120, 100%, 87.5%)", "rgb(191, 255, 191)", +"hsl(150, 100%, 87.5%)", "rgb(191, 255, 223)", +"hsl(180, 100%, 87.5%)", "rgb(191, 255, 255)", +"hsl(210, 100%, 87.5%)", "rgb(191, 223, 255)", +"hsl(240, 100%, 87.5%)", "rgb(191, 191, 255)", +"hsl(270, 100%, 87.5%)", "rgb(223, 191, 255)", +"hsl(300, 100%, 87.5%)", "rgb(255, 191, 255)", +"hsl(330, 100%, 87.5%)", "rgb(255, 191, 223)", +"hsl(0, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 0%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 25%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 50%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 75%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(30, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(60, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(90, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(120, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(150, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(180, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(210, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(240, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(270, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(300, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(330, 100%, 100%)", "rgb(255, 255, 255)", +"hsl(0, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(30, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(60, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(90, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(120, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(150, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(180, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(210, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(240, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(270, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(300, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(330, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsl(0, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(30, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(60, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(90, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(120, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(150, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(180, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(210, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(240, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(270, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(300, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(330, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsl(0, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 28)", +"hsl(30, 12.5%, 12.5%, 1.0)", "rgb(36, 32, 28)", +"hsl(60, 12.5%, 12.5%, 1.0)", "rgb(36, 36, 28)", +"hsl(90, 12.5%, 12.5%, 1.0)", "rgb(32, 36, 28)", +"hsl(120, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 28)", +"hsl(150, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 32)", +"hsl(180, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 36)", +"hsl(210, 12.5%, 12.5%, 1.0)", "rgb(28, 32, 36)", +"hsl(240, 12.5%, 12.5%, 1.0)", "rgb(28, 28, 36)", +"hsl(270, 12.5%, 12.5%, 1.0)", "rgb(32, 28, 36)", +"hsl(300, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 36)", +"hsl(330, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 32)", +"hsl(0, 25%, 12.5%, 1.0)", "rgb(40, 24, 24)", +"hsl(30, 25%, 12.5%, 1.0)", "rgb(40, 32, 24)", +"hsl(60, 25%, 12.5%, 1.0)", "rgb(40, 40, 24)", +"hsl(90, 25%, 12.5%, 1.0)", "rgb(32, 40, 24)", +"hsl(120, 25%, 12.5%, 1.0)", "rgb(24, 40, 24)", +"hsl(150, 25%, 12.5%, 1.0)", "rgb(24, 40, 32)", +"hsl(180, 25%, 12.5%, 1.0)", "rgb(24, 40, 40)", +"hsl(210, 25%, 12.5%, 1.0)", "rgb(24, 32, 40)", +"hsl(240, 25%, 12.5%, 1.0)", "rgb(24, 24, 40)", +"hsl(270, 25%, 12.5%, 1.0)", "rgb(32, 24, 40)", +"hsl(300, 25%, 12.5%, 1.0)", "rgb(40, 24, 40)", +"hsl(330, 25%, 12.5%, 1.0)", "rgb(40, 24, 32)", +"hsl(0, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 20)", +"hsl(30, 37.5%, 12.5%, 1.0)", "rgb(44, 32, 20)", +"hsl(60, 37.5%, 12.5%, 1.0)", "rgb(44, 44, 20)", +"hsl(90, 37.5%, 12.5%, 1.0)", "rgb(32, 44, 20)", +"hsl(120, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 20)", +"hsl(150, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 32)", +"hsl(180, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 44)", +"hsl(210, 37.5%, 12.5%, 1.0)", "rgb(20, 32, 44)", +"hsl(240, 37.5%, 12.5%, 1.0)", "rgb(20, 20, 44)", +"hsl(270, 37.5%, 12.5%, 1.0)", "rgb(32, 20, 44)", +"hsl(300, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 44)", +"hsl(330, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 32)", +"hsl(0, 50%, 12.5%, 1.0)", "rgb(48, 16, 16)", +"hsl(30, 50%, 12.5%, 1.0)", "rgb(48, 32, 16)", +"hsl(60, 50%, 12.5%, 1.0)", "rgb(48, 48, 16)", +"hsl(90, 50%, 12.5%, 1.0)", "rgb(32, 48, 16)", +"hsl(120, 50%, 12.5%, 1.0)", "rgb(16, 48, 16)", +"hsl(150, 50%, 12.5%, 1.0)", "rgb(16, 48, 32)", +"hsl(180, 50%, 12.5%, 1.0)", "rgb(16, 48, 48)", +"hsl(210, 50%, 12.5%, 1.0)", "rgb(16, 32, 48)", +"hsl(240, 50%, 12.5%, 1.0)", "rgb(16, 16, 48)", +"hsl(270, 50%, 12.5%, 1.0)", "rgb(32, 16, 48)", +"hsl(300, 50%, 12.5%, 1.0)", "rgb(48, 16, 48)", +"hsl(330, 50%, 12.5%, 1.0)", "rgb(48, 16, 32)", +"hsl(0, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 12)", +"hsl(30, 62.5%, 12.5%, 1.0)", "rgb(52, 32, 12)", +"hsl(60, 62.5%, 12.5%, 1.0)", "rgb(52, 52, 12)", +"hsl(90, 62.5%, 12.5%, 1.0)", "rgb(32, 52, 12)", +"hsl(120, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 12)", +"hsl(150, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 32)", +"hsl(180, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 52)", +"hsl(210, 62.5%, 12.5%, 1.0)", "rgb(12, 32, 52)", +"hsl(240, 62.5%, 12.5%, 1.0)", "rgb(12, 12, 52)", +"hsl(270, 62.5%, 12.5%, 1.0)", "rgb(32, 12, 52)", +"hsl(300, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 52)", +"hsl(330, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 32)", +"hsl(0, 75%, 12.5%, 1.0)", "rgb(56, 8, 8)", +"hsl(30, 75%, 12.5%, 1.0)", "rgb(56, 32, 8)", +"hsl(60, 75%, 12.5%, 1.0)", "rgb(56, 56, 8)", +"hsl(90, 75%, 12.5%, 1.0)", "rgb(32, 56, 8)", +"hsl(120, 75%, 12.5%, 1.0)", "rgb(8, 56, 8)", +"hsl(150, 75%, 12.5%, 1.0)", "rgb(8, 56, 32)", +"hsl(180, 75%, 12.5%, 1.0)", "rgb(8, 56, 56)", +"hsl(210, 75%, 12.5%, 1.0)", "rgb(8, 32, 56)", +"hsl(240, 75%, 12.5%, 1.0)", "rgb(8, 8, 56)", +"hsl(270, 75%, 12.5%, 1.0)", "rgb(32, 8, 56)", +"hsl(300, 75%, 12.5%, 1.0)", "rgb(56, 8, 56)", +"hsl(330, 75%, 12.5%, 1.0)", "rgb(56, 8, 32)", +"hsl(0, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 4)", +"hsl(30, 87.5%, 12.5%, 1.0)", "rgb(60, 32, 4)", +"hsl(60, 87.5%, 12.5%, 1.0)", "rgb(60, 60, 4)", +"hsl(90, 87.5%, 12.5%, 1.0)", "rgb(32, 60, 4)", +"hsl(120, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 4)", +"hsl(150, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 32)", +"hsl(180, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 60)", +"hsl(210, 87.5%, 12.5%, 1.0)", "rgb(4, 32, 60)", +"hsl(240, 87.5%, 12.5%, 1.0)", "rgb(4, 4, 60)", +"hsl(270, 87.5%, 12.5%, 1.0)", "rgb(32, 4, 60)", +"hsl(300, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 60)", +"hsl(330, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 32)", +"hsl(0, 100%, 12.5%, 1.0)", "rgb(64, 0, 0)", +"hsl(30, 100%, 12.5%, 1.0)", "rgb(64, 32, 0)", +"hsl(60, 100%, 12.5%, 1.0)", "rgb(64, 64, 0)", +"hsl(90, 100%, 12.5%, 1.0)", "rgb(32, 64, 0)", +"hsl(120, 100%, 12.5%, 1.0)", "rgb(0, 64, 0)", +"hsl(150, 100%, 12.5%, 1.0)", "rgb(0, 64, 32)", +"hsl(180, 100%, 12.5%, 1.0)", "rgb(0, 64, 64)", +"hsl(210, 100%, 12.5%, 1.0)", "rgb(0, 32, 64)", +"hsl(240, 100%, 12.5%, 1.0)", "rgb(0, 0, 64)", +"hsl(270, 100%, 12.5%, 1.0)", "rgb(32, 0, 64)", +"hsl(300, 100%, 12.5%, 1.0)", "rgb(64, 0, 64)", +"hsl(330, 100%, 12.5%, 1.0)", "rgb(64, 0, 32)", +"hsl(0, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(30, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(60, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(90, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(120, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(150, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(180, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(210, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(240, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(270, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(300, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(330, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsl(0, 12.5%, 25%, 1.0)", "rgb(72, 56, 56)", +"hsl(30, 12.5%, 25%, 1.0)", "rgb(72, 64, 56)", +"hsl(60, 12.5%, 25%, 1.0)", "rgb(72, 72, 56)", +"hsl(90, 12.5%, 25%, 1.0)", "rgb(64, 72, 56)", +"hsl(120, 12.5%, 25%, 1.0)", "rgb(56, 72, 56)", +"hsl(150, 12.5%, 25%, 1.0)", "rgb(56, 72, 64)", +"hsl(180, 12.5%, 25%, 1.0)", "rgb(56, 72, 72)", +"hsl(210, 12.5%, 25%, 1.0)", "rgb(56, 64, 72)", +"hsl(240, 12.5%, 25%, 1.0)", "rgb(56, 56, 72)", +"hsl(270, 12.5%, 25%, 1.0)", "rgb(64, 56, 72)", +"hsl(300, 12.5%, 25%, 1.0)", "rgb(72, 56, 72)", +"hsl(330, 12.5%, 25%, 1.0)", "rgb(72, 56, 64)", +"hsl(0, 25%, 25%, 1.0)", "rgb(80, 48, 48)", +"hsl(30, 25%, 25%, 1.0)", "rgb(80, 64, 48)", +"hsl(60, 25%, 25%, 1.0)", "rgb(80, 80, 48)", +"hsl(90, 25%, 25%, 1.0)", "rgb(64, 80, 48)", +"hsl(120, 25%, 25%, 1.0)", "rgb(48, 80, 48)", +"hsl(150, 25%, 25%, 1.0)", "rgb(48, 80, 64)", +"hsl(180, 25%, 25%, 1.0)", "rgb(48, 80, 80)", +"hsl(210, 25%, 25%, 1.0)", "rgb(48, 64, 80)", +"hsl(240, 25%, 25%, 1.0)", "rgb(48, 48, 80)", +"hsl(270, 25%, 25%, 1.0)", "rgb(64, 48, 80)", +"hsl(300, 25%, 25%, 1.0)", "rgb(80, 48, 80)", +"hsl(330, 25%, 25%, 1.0)", "rgb(80, 48, 64)", +"hsl(0, 37.5%, 25%, 1.0)", "rgb(88, 40, 40)", +"hsl(30, 37.5%, 25%, 1.0)", "rgb(88, 64, 40)", +"hsl(60, 37.5%, 25%, 1.0)", "rgb(88, 88, 40)", +"hsl(90, 37.5%, 25%, 1.0)", "rgb(64, 88, 40)", +"hsl(120, 37.5%, 25%, 1.0)", "rgb(40, 88, 40)", +"hsl(150, 37.5%, 25%, 1.0)", "rgb(40, 88, 64)", +"hsl(180, 37.5%, 25%, 1.0)", "rgb(40, 88, 88)", +"hsl(210, 37.5%, 25%, 1.0)", "rgb(40, 64, 88)", +"hsl(240, 37.5%, 25%, 1.0)", "rgb(40, 40, 88)", +"hsl(270, 37.5%, 25%, 1.0)", "rgb(64, 40, 88)", +"hsl(300, 37.5%, 25%, 1.0)", "rgb(88, 40, 88)", +"hsl(330, 37.5%, 25%, 1.0)", "rgb(88, 40, 64)", +"hsl(0, 50%, 25%, 1.0)", "rgb(96, 32, 32)", +"hsl(30, 50%, 25%, 1.0)", "rgb(96, 64, 32)", +"hsl(60, 50%, 25%, 1.0)", "rgb(96, 96, 32)", +"hsl(90, 50%, 25%, 1.0)", "rgb(64, 96, 32)", +"hsl(120, 50%, 25%, 1.0)", "rgb(32, 96, 32)", +"hsl(150, 50%, 25%, 1.0)", "rgb(32, 96, 64)", +"hsl(180, 50%, 25%, 1.0)", "rgb(32, 96, 96)", +"hsl(210, 50%, 25%, 1.0)", "rgb(32, 64, 96)", +"hsl(240, 50%, 25%, 1.0)", "rgb(32, 32, 96)", +"hsl(270, 50%, 25%, 1.0)", "rgb(64, 32, 96)", +"hsl(300, 50%, 25%, 1.0)", "rgb(96, 32, 96)", +"hsl(330, 50%, 25%, 1.0)", "rgb(96, 32, 64)", +"hsl(0, 62.5%, 25%, 1.0)", "rgb(104, 24, 24)", +"hsl(30, 62.5%, 25%, 1.0)", "rgb(104, 64, 24)", +"hsl(60, 62.5%, 25%, 1.0)", "rgb(104, 104, 24)", +"hsl(90, 62.5%, 25%, 1.0)", "rgb(64, 104, 24)", +"hsl(120, 62.5%, 25%, 1.0)", "rgb(24, 104, 24)", +"hsl(150, 62.5%, 25%, 1.0)", "rgb(24, 104, 64)", +"hsl(180, 62.5%, 25%, 1.0)", "rgb(24, 104, 104)", +"hsl(210, 62.5%, 25%, 1.0)", "rgb(24, 64, 104)", +"hsl(240, 62.5%, 25%, 1.0)", "rgb(24, 24, 104)", +"hsl(270, 62.5%, 25%, 1.0)", "rgb(64, 24, 104)", +"hsl(300, 62.5%, 25%, 1.0)", "rgb(104, 24, 104)", +"hsl(330, 62.5%, 25%, 1.0)", "rgb(104, 24, 64)", +"hsl(0, 75%, 25%, 1.0)", "rgb(112, 16, 16)", +"hsl(30, 75%, 25%, 1.0)", "rgb(112, 64, 16)", +"hsl(60, 75%, 25%, 1.0)", "rgb(112, 112, 16)", +"hsl(90, 75%, 25%, 1.0)", "rgb(64, 112, 16)", +"hsl(120, 75%, 25%, 1.0)", "rgb(16, 112, 16)", +"hsl(150, 75%, 25%, 1.0)", "rgb(16, 112, 64)", +"hsl(180, 75%, 25%, 1.0)", "rgb(16, 112, 112)", +"hsl(210, 75%, 25%, 1.0)", "rgb(16, 64, 112)", +"hsl(240, 75%, 25%, 1.0)", "rgb(16, 16, 112)", +"hsl(270, 75%, 25%, 1.0)", "rgb(64, 16, 112)", +"hsl(300, 75%, 25%, 1.0)", "rgb(112, 16, 112)", +"hsl(330, 75%, 25%, 1.0)", "rgb(112, 16, 64)", +"hsl(0, 87.5%, 25%, 1.0)", "rgb(120, 8, 8)", +"hsl(30, 87.5%, 25%, 1.0)", "rgb(120, 64, 8)", +"hsl(60, 87.5%, 25%, 1.0)", "rgb(120, 120, 8)", +"hsl(90, 87.5%, 25%, 1.0)", "rgb(64, 120, 8)", +"hsl(120, 87.5%, 25%, 1.0)", "rgb(8, 120, 8)", +"hsl(150, 87.5%, 25%, 1.0)", "rgb(8, 120, 64)", +"hsl(180, 87.5%, 25%, 1.0)", "rgb(8, 120, 120)", +"hsl(210, 87.5%, 25%, 1.0)", "rgb(8, 64, 120)", +"hsl(240, 87.5%, 25%, 1.0)", "rgb(8, 8, 120)", +"hsl(270, 87.5%, 25%, 1.0)", "rgb(64, 8, 120)", +"hsl(300, 87.5%, 25%, 1.0)", "rgb(120, 8, 120)", +"hsl(330, 87.5%, 25%, 1.0)", "rgb(120, 8, 64)", +"hsl(0, 100%, 25%, 1.0)", "rgb(128, 0, 0)", +"hsl(30, 100%, 25%, 1.0)", "rgb(128, 64, 0)", +"hsl(60, 100%, 25%, 1.0)", "rgb(128, 128, 0)", +"hsl(90, 100%, 25%, 1.0)", "rgb(64, 128, 0)", +"hsl(120, 100%, 25%, 1.0)", "rgb(0, 128, 0)", +"hsl(150, 100%, 25%, 1.0)", "rgb(0, 128, 64)", +"hsl(180, 100%, 25%, 1.0)", "rgb(0, 128, 128)", +"hsl(210, 100%, 25%, 1.0)", "rgb(0, 64, 128)", +"hsl(240, 100%, 25%, 1.0)", "rgb(0, 0, 128)", +"hsl(270, 100%, 25%, 1.0)", "rgb(64, 0, 128)", +"hsl(300, 100%, 25%, 1.0)", "rgb(128, 0, 128)", +"hsl(330, 100%, 25%, 1.0)", "rgb(128, 0, 64)", +"hsl(0, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(30, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(60, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(90, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(120, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(150, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(180, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(210, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(240, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(270, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(300, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(330, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsl(0, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 84)", +"hsl(30, 12.5%, 37.5%, 1.0)", "rgb(108, 96, 84)", +"hsl(60, 12.5%, 37.5%, 1.0)", "rgb(108, 108, 84)", +"hsl(90, 12.5%, 37.5%, 1.0)", "rgb(96, 108, 84)", +"hsl(120, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 84)", +"hsl(150, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 96)", +"hsl(180, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 108)", +"hsl(210, 12.5%, 37.5%, 1.0)", "rgb(84, 96, 108)", +"hsl(240, 12.5%, 37.5%, 1.0)", "rgb(84, 84, 108)", +"hsl(270, 12.5%, 37.5%, 1.0)", "rgb(96, 84, 108)", +"hsl(300, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 108)", +"hsl(330, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 96)", +"hsl(0, 25%, 37.5%, 1.0)", "rgb(120, 72, 72)", +"hsl(30, 25%, 37.5%, 1.0)", "rgb(120, 96, 72)", +"hsl(60, 25%, 37.5%, 1.0)", "rgb(120, 120, 72)", +"hsl(90, 25%, 37.5%, 1.0)", "rgb(96, 120, 72)", +"hsl(120, 25%, 37.5%, 1.0)", "rgb(72, 120, 72)", +"hsl(150, 25%, 37.5%, 1.0)", "rgb(72, 120, 96)", +"hsl(180, 25%, 37.5%, 1.0)", "rgb(72, 120, 120)", +"hsl(210, 25%, 37.5%, 1.0)", "rgb(72, 96, 120)", +"hsl(240, 25%, 37.5%, 1.0)", "rgb(72, 72, 120)", +"hsl(270, 25%, 37.5%, 1.0)", "rgb(96, 72, 120)", +"hsl(300, 25%, 37.5%, 1.0)", "rgb(120, 72, 120)", +"hsl(330, 25%, 37.5%, 1.0)", "rgb(120, 72, 96)", +"hsl(0, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 60)", +"hsl(30, 37.5%, 37.5%, 1.0)", "rgb(131, 96, 60)", +"hsl(60, 37.5%, 37.5%, 1.0)", "rgb(131, 131, 60)", +"hsl(90, 37.5%, 37.5%, 1.0)", "rgb(96, 131, 60)", +"hsl(120, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 60)", +"hsl(150, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 96)", +"hsl(180, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 131)", +"hsl(210, 37.5%, 37.5%, 1.0)", "rgb(60, 96, 131)", +"hsl(240, 37.5%, 37.5%, 1.0)", "rgb(60, 60, 131)", +"hsl(270, 37.5%, 37.5%, 1.0)", "rgb(96, 60, 131)", +"hsl(300, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 131)", +"hsl(330, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 96)", +"hsl(0, 50%, 37.5%, 1.0)", "rgb(143, 48, 48)", +"hsl(30, 50%, 37.5%, 1.0)", "rgb(143, 96, 48)", +"hsl(60, 50%, 37.5%, 1.0)", "rgb(143, 143, 48)", +"hsl(90, 50%, 37.5%, 1.0)", "rgb(96, 143, 48)", +"hsl(120, 50%, 37.5%, 1.0)", "rgb(48, 143, 48)", +"hsl(150, 50%, 37.5%, 1.0)", "rgb(48, 143, 96)", +"hsl(180, 50%, 37.5%, 1.0)", "rgb(48, 143, 143)", +"hsl(210, 50%, 37.5%, 1.0)", "rgb(48, 96, 143)", +"hsl(240, 50%, 37.5%, 1.0)", "rgb(48, 48, 143)", +"hsl(270, 50%, 37.5%, 1.0)", "rgb(96, 48, 143)", +"hsl(300, 50%, 37.5%, 1.0)", "rgb(143, 48, 143)", +"hsl(330, 50%, 37.5%, 1.0)", "rgb(143, 48, 96)", +"hsl(0, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 36)", +"hsl(30, 62.5%, 37.5%, 1.0)", "rgb(155, 96, 36)", +"hsl(60, 62.5%, 37.5%, 1.0)", "rgb(155, 155, 36)", +"hsl(90, 62.5%, 37.5%, 1.0)", "rgb(96, 155, 36)", +"hsl(120, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 36)", +"hsl(150, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 96)", +"hsl(180, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 155)", +"hsl(210, 62.5%, 37.5%, 1.0)", "rgb(36, 96, 155)", +"hsl(240, 62.5%, 37.5%, 1.0)", "rgb(36, 36, 155)", +"hsl(270, 62.5%, 37.5%, 1.0)", "rgb(96, 36, 155)", +"hsl(300, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 155)", +"hsl(330, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 96)", +"hsl(0, 75%, 37.5%, 1.0)", "rgb(167, 24, 24)", +"hsl(30, 75%, 37.5%, 1.0)", "rgb(167, 96, 24)", +"hsl(60, 75%, 37.5%, 1.0)", "rgb(167, 167, 24)", +"hsl(90, 75%, 37.5%, 1.0)", "rgb(96, 167, 24)", +"hsl(120, 75%, 37.5%, 1.0)", "rgb(24, 167, 24)", +"hsl(150, 75%, 37.5%, 1.0)", "rgb(24, 167, 96)", +"hsl(180, 75%, 37.5%, 1.0)", "rgb(24, 167, 167)", +"hsl(210, 75%, 37.5%, 1.0)", "rgb(24, 96, 167)", +"hsl(240, 75%, 37.5%, 1.0)", "rgb(24, 24, 167)", +"hsl(270, 75%, 37.5%, 1.0)", "rgb(96, 24, 167)", +"hsl(300, 75%, 37.5%, 1.0)", "rgb(167, 24, 167)", +"hsl(330, 75%, 37.5%, 1.0)", "rgb(167, 24, 96)", +"hsl(0, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 12)", +"hsl(30, 87.5%, 37.5%, 1.0)", "rgb(179, 96, 12)", +"hsl(60, 87.5%, 37.5%, 1.0)", "rgb(179, 179, 12)", +"hsl(90, 87.5%, 37.5%, 1.0)", "rgb(96, 179, 12)", +"hsl(120, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 12)", +"hsl(150, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 96)", +"hsl(180, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 179)", +"hsl(210, 87.5%, 37.5%, 1.0)", "rgb(12, 96, 179)", +"hsl(240, 87.5%, 37.5%, 1.0)", "rgb(12, 12, 179)", +"hsl(270, 87.5%, 37.5%, 1.0)", "rgb(96, 12, 179)", +"hsl(300, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 179)", +"hsl(330, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 96)", +"hsl(0, 100%, 37.5%, 1.0)", "rgb(191, 0, 0)", +"hsl(30, 100%, 37.5%, 1.0)", "rgb(191, 96, 0)", +"hsl(60, 100%, 37.5%, 1.0)", "rgb(191, 191, 0)", +"hsl(90, 100%, 37.5%, 1.0)", "rgb(96, 191, 0)", +"hsl(120, 100%, 37.5%, 1.0)", "rgb(0, 191, 0)", +"hsl(150, 100%, 37.5%, 1.0)", "rgb(0, 191, 96)", +"hsl(180, 100%, 37.5%, 1.0)", "rgb(0, 191, 191)", +"hsl(210, 100%, 37.5%, 1.0)", "rgb(0, 96, 191)", +"hsl(240, 100%, 37.5%, 1.0)", "rgb(0, 0, 191)", +"hsl(270, 100%, 37.5%, 1.0)", "rgb(96, 0, 191)", +"hsl(300, 100%, 37.5%, 1.0)", "rgb(191, 0, 191)", +"hsl(330, 100%, 37.5%, 1.0)", "rgb(191, 0, 96)", +"hsl(0, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(30, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(60, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(90, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(120, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(150, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(180, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(210, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(240, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(270, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(300, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(330, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsl(0, 12.5%, 50%, 1.0)", "rgb(143, 112, 112)", +"hsl(30, 12.5%, 50%, 1.0)", "rgb(143, 128, 112)", +"hsl(60, 12.5%, 50%, 1.0)", "rgb(143, 143, 112)", +"hsl(90, 12.5%, 50%, 1.0)", "rgb(128, 143, 112)", +"hsl(120, 12.5%, 50%, 1.0)", "rgb(112, 143, 112)", +"hsl(150, 12.5%, 50%, 1.0)", "rgb(112, 143, 128)", +"hsl(180, 12.5%, 50%, 1.0)", "rgb(112, 143, 143)", +"hsl(210, 12.5%, 50%, 1.0)", "rgb(112, 128, 143)", +"hsl(240, 12.5%, 50%, 1.0)", "rgb(112, 112, 143)", +"hsl(270, 12.5%, 50%, 1.0)", "rgb(128, 112, 143)", +"hsl(300, 12.5%, 50%, 1.0)", "rgb(143, 112, 143)", +"hsl(330, 12.5%, 50%, 1.0)", "rgb(143, 112, 128)", +"hsl(0, 25%, 50%, 1.0)", "rgb(159, 96, 96)", +"hsl(30, 25%, 50%, 1.0)", "rgb(159, 128, 96)", +"hsl(60, 25%, 50%, 1.0)", "rgb(159, 159, 96)", +"hsl(90, 25%, 50%, 1.0)", "rgb(128, 159, 96)", +"hsl(120, 25%, 50%, 1.0)", "rgb(96, 159, 96)", +"hsl(150, 25%, 50%, 1.0)", "rgb(96, 159, 128)", +"hsl(180, 25%, 50%, 1.0)", "rgb(96, 159, 159)", +"hsl(210, 25%, 50%, 1.0)", "rgb(96, 128, 159)", +"hsl(240, 25%, 50%, 1.0)", "rgb(96, 96, 159)", +"hsl(270, 25%, 50%, 1.0)", "rgb(128, 96, 159)", +"hsl(300, 25%, 50%, 1.0)", "rgb(159, 96, 159)", +"hsl(330, 25%, 50%, 1.0)", "rgb(159, 96, 128)", +"hsl(0, 37.5%, 50%, 1.0)", "rgb(175, 80, 80)", +"hsl(30, 37.5%, 50%, 1.0)", "rgb(175, 128, 80)", +"hsl(60, 37.5%, 50%, 1.0)", "rgb(175, 175, 80)", +"hsl(90, 37.5%, 50%, 1.0)", "rgb(128, 175, 80)", +"hsl(120, 37.5%, 50%, 1.0)", "rgb(80, 175, 80)", +"hsl(150, 37.5%, 50%, 1.0)", "rgb(80, 175, 128)", +"hsl(180, 37.5%, 50%, 1.0)", "rgb(80, 175, 175)", +"hsl(210, 37.5%, 50%, 1.0)", "rgb(80, 128, 175)", +"hsl(240, 37.5%, 50%, 1.0)", "rgb(80, 80, 175)", +"hsl(270, 37.5%, 50%, 1.0)", "rgb(128, 80, 175)", +"hsl(300, 37.5%, 50%, 1.0)", "rgb(175, 80, 175)", +"hsl(330, 37.5%, 50%, 1.0)", "rgb(175, 80, 128)", +"hsl(0, 50%, 50%, 1.0)", "rgb(191, 64, 64)", +"hsl(30, 50%, 50%, 1.0)", "rgb(191, 128, 64)", +"hsl(60, 50%, 50%, 1.0)", "rgb(191, 191, 64)", +"hsl(90, 50%, 50%, 1.0)", "rgb(128, 191, 64)", +"hsl(120, 50%, 50%, 1.0)", "rgb(64, 191, 64)", +"hsl(150, 50%, 50%, 1.0)", "rgb(64, 191, 128)", +"hsl(180, 50%, 50%, 1.0)", "rgb(64, 191, 191)", +"hsl(210, 50%, 50%, 1.0)", "rgb(64, 128, 191)", +"hsl(240, 50%, 50%, 1.0)", "rgb(64, 64, 191)", +"hsl(270, 50%, 50%, 1.0)", "rgb(128, 64, 191)", +"hsl(300, 50%, 50%, 1.0)", "rgb(191, 64, 191)", +"hsl(330, 50%, 50%, 1.0)", "rgb(191, 64, 128)", +"hsl(0, 62.5%, 50%, 1.0)", "rgb(207, 48, 48)", +"hsl(30, 62.5%, 50%, 1.0)", "rgb(207, 128, 48)", +"hsl(60, 62.5%, 50%, 1.0)", "rgb(207, 207, 48)", +"hsl(90, 62.5%, 50%, 1.0)", "rgb(128, 207, 48)", +"hsl(120, 62.5%, 50%, 1.0)", "rgb(48, 207, 48)", +"hsl(150, 62.5%, 50%, 1.0)", "rgb(48, 207, 128)", +"hsl(180, 62.5%, 50%, 1.0)", "rgb(48, 207, 207)", +"hsl(210, 62.5%, 50%, 1.0)", "rgb(48, 128, 207)", +"hsl(240, 62.5%, 50%, 1.0)", "rgb(48, 48, 207)", +"hsl(270, 62.5%, 50%, 1.0)", "rgb(128, 48, 207)", +"hsl(300, 62.5%, 50%, 1.0)", "rgb(207, 48, 207)", +"hsl(330, 62.5%, 50%, 1.0)", "rgb(207, 48, 128)", +"hsl(0, 75%, 50%, 1.0)", "rgb(223, 32, 32)", +"hsl(30, 75%, 50%, 1.0)", "rgb(223, 128, 32)", +"hsl(60, 75%, 50%, 1.0)", "rgb(223, 223, 32)", +"hsl(90, 75%, 50%, 1.0)", "rgb(128, 223, 32)", +"hsl(120, 75%, 50%, 1.0)", "rgb(32, 223, 32)", +"hsl(150, 75%, 50%, 1.0)", "rgb(32, 223, 128)", +"hsl(180, 75%, 50%, 1.0)", "rgb(32, 223, 223)", +"hsl(210, 75%, 50%, 1.0)", "rgb(32, 128, 223)", +"hsl(240, 75%, 50%, 1.0)", "rgb(32, 32, 223)", +"hsl(270, 75%, 50%, 1.0)", "rgb(128, 32, 223)", +"hsl(300, 75%, 50%, 1.0)", "rgb(223, 32, 223)", +"hsl(330, 75%, 50%, 1.0)", "rgb(223, 32, 128)", +"hsl(0, 87.5%, 50%, 1.0)", "rgb(239, 16, 16)", +"hsl(30, 87.5%, 50%, 1.0)", "rgb(239, 128, 16)", +"hsl(60, 87.5%, 50%, 1.0)", "rgb(239, 239, 16)", +"hsl(90, 87.5%, 50%, 1.0)", "rgb(128, 239, 16)", +"hsl(120, 87.5%, 50%, 1.0)", "rgb(16, 239, 16)", +"hsl(150, 87.5%, 50%, 1.0)", "rgb(16, 239, 128)", +"hsl(180, 87.5%, 50%, 1.0)", "rgb(16, 239, 239)", +"hsl(210, 87.5%, 50%, 1.0)", "rgb(16, 128, 239)", +"hsl(240, 87.5%, 50%, 1.0)", "rgb(16, 16, 239)", +"hsl(270, 87.5%, 50%, 1.0)", "rgb(128, 16, 239)", +"hsl(300, 87.5%, 50%, 1.0)", "rgb(239, 16, 239)", +"hsl(330, 87.5%, 50%, 1.0)", "rgb(239, 16, 128)", +"hsl(0, 100%, 50%, 1.0)", "rgb(255, 0, 0)", +"hsl(30, 100%, 50%, 1.0)", "rgb(255, 128, 0)", +"hsl(60, 100%, 50%, 1.0)", "rgb(255, 255, 0)", +"hsl(90, 100%, 50%, 1.0)", "rgb(128, 255, 0)", +"hsl(120, 100%, 50%, 1.0)", "rgb(0, 255, 0)", +"hsl(150, 100%, 50%, 1.0)", "rgb(0, 255, 128)", +"hsl(180, 100%, 50%, 1.0)", "rgb(0, 255, 255)", +"hsl(210, 100%, 50%, 1.0)", "rgb(0, 128, 255)", +"hsl(240, 100%, 50%, 1.0)", "rgb(0, 0, 255)", +"hsl(270, 100%, 50%, 1.0)", "rgb(128, 0, 255)", +"hsl(300, 100%, 50%, 1.0)", "rgb(255, 0, 255)", +"hsl(330, 100%, 50%, 1.0)", "rgb(255, 0, 128)", +"hsl(0, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(30, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(60, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(90, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(120, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(150, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(180, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(210, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(240, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(270, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(300, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(330, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsl(0, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 147)", +"hsl(30, 12.5%, 62.5%, 1.0)", "rgb(171, 159, 147)", +"hsl(60, 12.5%, 62.5%, 1.0)", "rgb(171, 171, 147)", +"hsl(90, 12.5%, 62.5%, 1.0)", "rgb(159, 171, 147)", +"hsl(120, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 147)", +"hsl(150, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 159)", +"hsl(180, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 171)", +"hsl(210, 12.5%, 62.5%, 1.0)", "rgb(147, 159, 171)", +"hsl(240, 12.5%, 62.5%, 1.0)", "rgb(147, 147, 171)", +"hsl(270, 12.5%, 62.5%, 1.0)", "rgb(159, 147, 171)", +"hsl(300, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 171)", +"hsl(330, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 159)", +"hsl(0, 25%, 62.5%, 1.0)", "rgb(183, 135, 135)", +"hsl(30, 25%, 62.5%, 1.0)", "rgb(183, 159, 135)", +"hsl(60, 25%, 62.5%, 1.0)", "rgb(183, 183, 135)", +"hsl(90, 25%, 62.5%, 1.0)", "rgb(159, 183, 135)", +"hsl(120, 25%, 62.5%, 1.0)", "rgb(135, 183, 135)", +"hsl(150, 25%, 62.5%, 1.0)", "rgb(135, 183, 159)", +"hsl(180, 25%, 62.5%, 1.0)", "rgb(135, 183, 183)", +"hsl(210, 25%, 62.5%, 1.0)", "rgb(135, 159, 183)", +"hsl(240, 25%, 62.5%, 1.0)", "rgb(135, 135, 183)", +"hsl(270, 25%, 62.5%, 1.0)", "rgb(159, 135, 183)", +"hsl(300, 25%, 62.5%, 1.0)", "rgb(183, 135, 183)", +"hsl(330, 25%, 62.5%, 1.0)", "rgb(183, 135, 159)", +"hsl(0, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 124)", +"hsl(30, 37.5%, 62.5%, 1.0)", "rgb(195, 159, 124)", +"hsl(60, 37.5%, 62.5%, 1.0)", "rgb(195, 195, 124)", +"hsl(90, 37.5%, 62.5%, 1.0)", "rgb(159, 195, 124)", +"hsl(120, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 124)", +"hsl(150, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 159)", +"hsl(180, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 195)", +"hsl(210, 37.5%, 62.5%, 1.0)", "rgb(124, 159, 195)", +"hsl(240, 37.5%, 62.5%, 1.0)", "rgb(124, 124, 195)", +"hsl(270, 37.5%, 62.5%, 1.0)", "rgb(159, 124, 195)", +"hsl(300, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 195)", +"hsl(330, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 159)", +"hsl(0, 50%, 62.5%, 1.0)", "rgb(207, 112, 112)", +"hsl(30, 50%, 62.5%, 1.0)", "rgb(207, 159, 112)", +"hsl(60, 50%, 62.5%, 1.0)", "rgb(207, 207, 112)", +"hsl(90, 50%, 62.5%, 1.0)", "rgb(159, 207, 112)", +"hsl(120, 50%, 62.5%, 1.0)", "rgb(112, 207, 112)", +"hsl(150, 50%, 62.5%, 1.0)", "rgb(112, 207, 159)", +"hsl(180, 50%, 62.5%, 1.0)", "rgb(112, 207, 207)", +"hsl(210, 50%, 62.5%, 1.0)", "rgb(112, 159, 207)", +"hsl(240, 50%, 62.5%, 1.0)", "rgb(112, 112, 207)", +"hsl(270, 50%, 62.5%, 1.0)", "rgb(159, 112, 207)", +"hsl(300, 50%, 62.5%, 1.0)", "rgb(207, 112, 207)", +"hsl(330, 50%, 62.5%, 1.0)", "rgb(207, 112, 159)", +"hsl(0, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 100)", +"hsl(30, 62.5%, 62.5%, 1.0)", "rgb(219, 159, 100)", +"hsl(60, 62.5%, 62.5%, 1.0)", "rgb(219, 219, 100)", +"hsl(90, 62.5%, 62.5%, 1.0)", "rgb(159, 219, 100)", +"hsl(120, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 100)", +"hsl(150, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 159)", +"hsl(180, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 219)", +"hsl(210, 62.5%, 62.5%, 1.0)", "rgb(100, 159, 219)", +"hsl(240, 62.5%, 62.5%, 1.0)", "rgb(100, 100, 219)", +"hsl(270, 62.5%, 62.5%, 1.0)", "rgb(159, 100, 219)", +"hsl(300, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 219)", +"hsl(330, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 159)", +"hsl(0, 75%, 62.5%, 1.0)", "rgb(231, 88, 88)", +"hsl(30, 75%, 62.5%, 1.0)", "rgb(231, 159, 88)", +"hsl(60, 75%, 62.5%, 1.0)", "rgb(231, 231, 88)", +"hsl(90, 75%, 62.5%, 1.0)", "rgb(159, 231, 88)", +"hsl(120, 75%, 62.5%, 1.0)", "rgb(88, 231, 88)", +"hsl(150, 75%, 62.5%, 1.0)", "rgb(88, 231, 159)", +"hsl(180, 75%, 62.5%, 1.0)", "rgb(88, 231, 231)", +"hsl(210, 75%, 62.5%, 1.0)", "rgb(88, 159, 231)", +"hsl(240, 75%, 62.5%, 1.0)", "rgb(88, 88, 231)", +"hsl(270, 75%, 62.5%, 1.0)", "rgb(159, 88, 231)", +"hsl(300, 75%, 62.5%, 1.0)", "rgb(231, 88, 231)", +"hsl(330, 75%, 62.5%, 1.0)", "rgb(231, 88, 159)", +"hsl(0, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 76)", +"hsl(30, 87.5%, 62.5%, 1.0)", "rgb(243, 159, 76)", +"hsl(60, 87.5%, 62.5%, 1.0)", "rgb(243, 243, 76)", +"hsl(90, 87.5%, 62.5%, 1.0)", "rgb(159, 243, 76)", +"hsl(120, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 76)", +"hsl(150, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 159)", +"hsl(180, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 243)", +"hsl(210, 87.5%, 62.5%, 1.0)", "rgb(76, 159, 243)", +"hsl(240, 87.5%, 62.5%, 1.0)", "rgb(76, 76, 243)", +"hsl(270, 87.5%, 62.5%, 1.0)", "rgb(159, 76, 243)", +"hsl(300, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 243)", +"hsl(330, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 159)", +"hsl(0, 100%, 62.5%, 1.0)", "rgb(255, 64, 64)", +"hsl(30, 100%, 62.5%, 1.0)", "rgb(255, 159, 64)", +"hsl(60, 100%, 62.5%, 1.0)", "rgb(255, 255, 64)", +"hsl(90, 100%, 62.5%, 1.0)", "rgb(159, 255, 64)", +"hsl(120, 100%, 62.5%, 1.0)", "rgb(64, 255, 64)", +"hsl(150, 100%, 62.5%, 1.0)", "rgb(64, 255, 159)", +"hsl(180, 100%, 62.5%, 1.0)", "rgb(64, 255, 255)", +"hsl(210, 100%, 62.5%, 1.0)", "rgb(64, 159, 255)", +"hsl(240, 100%, 62.5%, 1.0)", "rgb(64, 64, 255)", +"hsl(270, 100%, 62.5%, 1.0)", "rgb(159, 64, 255)", +"hsl(300, 100%, 62.5%, 1.0)", "rgb(255, 64, 255)", +"hsl(330, 100%, 62.5%, 1.0)", "rgb(255, 64, 159)", +"hsl(0, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(30, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(60, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(90, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(120, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(150, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(180, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(210, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(240, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(270, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(300, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(330, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsl(0, 12.5%, 75%, 1.0)", "rgb(199, 183, 183)", +"hsl(30, 12.5%, 75%, 1.0)", "rgb(199, 191, 183)", +"hsl(60, 12.5%, 75%, 1.0)", "rgb(199, 199, 183)", +"hsl(90, 12.5%, 75%, 1.0)", "rgb(191, 199, 183)", +"hsl(120, 12.5%, 75%, 1.0)", "rgb(183, 199, 183)", +"hsl(150, 12.5%, 75%, 1.0)", "rgb(183, 199, 191)", +"hsl(180, 12.5%, 75%, 1.0)", "rgb(183, 199, 199)", +"hsl(210, 12.5%, 75%, 1.0)", "rgb(183, 191, 199)", +"hsl(240, 12.5%, 75%, 1.0)", "rgb(183, 183, 199)", +"hsl(270, 12.5%, 75%, 1.0)", "rgb(191, 183, 199)", +"hsl(300, 12.5%, 75%, 1.0)", "rgb(199, 183, 199)", +"hsl(330, 12.5%, 75%, 1.0)", "rgb(199, 183, 191)", +"hsl(0, 25%, 75%, 1.0)", "rgb(207, 175, 175)", +"hsl(30, 25%, 75%, 1.0)", "rgb(207, 191, 175)", +"hsl(60, 25%, 75%, 1.0)", "rgb(207, 207, 175)", +"hsl(90, 25%, 75%, 1.0)", "rgb(191, 207, 175)", +"hsl(120, 25%, 75%, 1.0)", "rgb(175, 207, 175)", +"hsl(150, 25%, 75%, 1.0)", "rgb(175, 207, 191)", +"hsl(180, 25%, 75%, 1.0)", "rgb(175, 207, 207)", +"hsl(210, 25%, 75%, 1.0)", "rgb(175, 191, 207)", +"hsl(240, 25%, 75%, 1.0)", "rgb(175, 175, 207)", +"hsl(270, 25%, 75%, 1.0)", "rgb(191, 175, 207)", +"hsl(300, 25%, 75%, 1.0)", "rgb(207, 175, 207)", +"hsl(330, 25%, 75%, 1.0)", "rgb(207, 175, 191)", +"hsl(0, 37.5%, 75%, 1.0)", "rgb(215, 167, 167)", +"hsl(30, 37.5%, 75%, 1.0)", "rgb(215, 191, 167)", +"hsl(60, 37.5%, 75%, 1.0)", "rgb(215, 215, 167)", +"hsl(90, 37.5%, 75%, 1.0)", "rgb(191, 215, 167)", +"hsl(120, 37.5%, 75%, 1.0)", "rgb(167, 215, 167)", +"hsl(150, 37.5%, 75%, 1.0)", "rgb(167, 215, 191)", +"hsl(180, 37.5%, 75%, 1.0)", "rgb(167, 215, 215)", +"hsl(210, 37.5%, 75%, 1.0)", "rgb(167, 191, 215)", +"hsl(240, 37.5%, 75%, 1.0)", "rgb(167, 167, 215)", +"hsl(270, 37.5%, 75%, 1.0)", "rgb(191, 167, 215)", +"hsl(300, 37.5%, 75%, 1.0)", "rgb(215, 167, 215)", +"hsl(330, 37.5%, 75%, 1.0)", "rgb(215, 167, 191)", +"hsl(0, 50%, 75%, 1.0)", "rgb(223, 159, 159)", +"hsl(30, 50%, 75%, 1.0)", "rgb(223, 191, 159)", +"hsl(60, 50%, 75%, 1.0)", "rgb(223, 223, 159)", +"hsl(90, 50%, 75%, 1.0)", "rgb(191, 223, 159)", +"hsl(120, 50%, 75%, 1.0)", "rgb(159, 223, 159)", +"hsl(150, 50%, 75%, 1.0)", "rgb(159, 223, 191)", +"hsl(180, 50%, 75%, 1.0)", "rgb(159, 223, 223)", +"hsl(210, 50%, 75%, 1.0)", "rgb(159, 191, 223)", +"hsl(240, 50%, 75%, 1.0)", "rgb(159, 159, 223)", +"hsl(270, 50%, 75%, 1.0)", "rgb(191, 159, 223)", +"hsl(300, 50%, 75%, 1.0)", "rgb(223, 159, 223)", +"hsl(330, 50%, 75%, 1.0)", "rgb(223, 159, 191)", +"hsl(0, 62.5%, 75%, 1.0)", "rgb(231, 151, 151)", +"hsl(30, 62.5%, 75%, 1.0)", "rgb(231, 191, 151)", +"hsl(60, 62.5%, 75%, 1.0)", "rgb(231, 231, 151)", +"hsl(90, 62.5%, 75%, 1.0)", "rgb(191, 231, 151)", +"hsl(120, 62.5%, 75%, 1.0)", "rgb(151, 231, 151)", +"hsl(150, 62.5%, 75%, 1.0)", "rgb(151, 231, 191)", +"hsl(180, 62.5%, 75%, 1.0)", "rgb(151, 231, 231)", +"hsl(210, 62.5%, 75%, 1.0)", "rgb(151, 191, 231)", +"hsl(240, 62.5%, 75%, 1.0)", "rgb(151, 151, 231)", +"hsl(270, 62.5%, 75%, 1.0)", "rgb(191, 151, 231)", +"hsl(300, 62.5%, 75%, 1.0)", "rgb(231, 151, 231)", +"hsl(330, 62.5%, 75%, 1.0)", "rgb(231, 151, 191)", +"hsl(0, 75%, 75%, 1.0)", "rgb(239, 143, 143)", +"hsl(30, 75%, 75%, 1.0)", "rgb(239, 191, 143)", +"hsl(60, 75%, 75%, 1.0)", "rgb(239, 239, 143)", +"hsl(90, 75%, 75%, 1.0)", "rgb(191, 239, 143)", +"hsl(120, 75%, 75%, 1.0)", "rgb(143, 239, 143)", +"hsl(150, 75%, 75%, 1.0)", "rgb(143, 239, 191)", +"hsl(180, 75%, 75%, 1.0)", "rgb(143, 239, 239)", +"hsl(210, 75%, 75%, 1.0)", "rgb(143, 191, 239)", +"hsl(240, 75%, 75%, 1.0)", "rgb(143, 143, 239)", +"hsl(270, 75%, 75%, 1.0)", "rgb(191, 143, 239)", +"hsl(300, 75%, 75%, 1.0)", "rgb(239, 143, 239)", +"hsl(330, 75%, 75%, 1.0)", "rgb(239, 143, 191)", +"hsl(0, 87.5%, 75%, 1.0)", "rgb(247, 135, 135)", +"hsl(30, 87.5%, 75%, 1.0)", "rgb(247, 191, 135)", +"hsl(60, 87.5%, 75%, 1.0)", "rgb(247, 247, 135)", +"hsl(90, 87.5%, 75%, 1.0)", "rgb(191, 247, 135)", +"hsl(120, 87.5%, 75%, 1.0)", "rgb(135, 247, 135)", +"hsl(150, 87.5%, 75%, 1.0)", "rgb(135, 247, 191)", +"hsl(180, 87.5%, 75%, 1.0)", "rgb(135, 247, 247)", +"hsl(210, 87.5%, 75%, 1.0)", "rgb(135, 191, 247)", +"hsl(240, 87.5%, 75%, 1.0)", "rgb(135, 135, 247)", +"hsl(270, 87.5%, 75%, 1.0)", "rgb(191, 135, 247)", +"hsl(300, 87.5%, 75%, 1.0)", "rgb(247, 135, 247)", +"hsl(330, 87.5%, 75%, 1.0)", "rgb(247, 135, 191)", +"hsl(0, 100%, 75%, 1.0)", "rgb(255, 128, 128)", +"hsl(30, 100%, 75%, 1.0)", "rgb(255, 191, 128)", +"hsl(60, 100%, 75%, 1.0)", "rgb(255, 255, 128)", +"hsl(90, 100%, 75%, 1.0)", "rgb(191, 255, 128)", +"hsl(120, 100%, 75%, 1.0)", "rgb(128, 255, 128)", +"hsl(150, 100%, 75%, 1.0)", "rgb(128, 255, 191)", +"hsl(180, 100%, 75%, 1.0)", "rgb(128, 255, 255)", +"hsl(210, 100%, 75%, 1.0)", "rgb(128, 191, 255)", +"hsl(240, 100%, 75%, 1.0)", "rgb(128, 128, 255)", +"hsl(270, 100%, 75%, 1.0)", "rgb(191, 128, 255)", +"hsl(300, 100%, 75%, 1.0)", "rgb(255, 128, 255)", +"hsl(330, 100%, 75%, 1.0)", "rgb(255, 128, 191)", +"hsl(0, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(30, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(60, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(90, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(120, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(150, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(180, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(210, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(240, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(270, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(300, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(330, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsl(0, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 219)", +"hsl(30, 12.5%, 87.5%, 1.0)", "rgb(227, 223, 219)", +"hsl(60, 12.5%, 87.5%, 1.0)", "rgb(227, 227, 219)", +"hsl(90, 12.5%, 87.5%, 1.0)", "rgb(223, 227, 219)", +"hsl(120, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 219)", +"hsl(150, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 223)", +"hsl(180, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 227)", +"hsl(210, 12.5%, 87.5%, 1.0)", "rgb(219, 223, 227)", +"hsl(240, 12.5%, 87.5%, 1.0)", "rgb(219, 219, 227)", +"hsl(270, 12.5%, 87.5%, 1.0)", "rgb(223, 219, 227)", +"hsl(300, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 227)", +"hsl(330, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 223)", +"hsl(0, 25%, 87.5%, 1.0)", "rgb(231, 215, 215)", +"hsl(30, 25%, 87.5%, 1.0)", "rgb(231, 223, 215)", +"hsl(60, 25%, 87.5%, 1.0)", "rgb(231, 231, 215)", +"hsl(90, 25%, 87.5%, 1.0)", "rgb(223, 231, 215)", +"hsl(120, 25%, 87.5%, 1.0)", "rgb(215, 231, 215)", +"hsl(150, 25%, 87.5%, 1.0)", "rgb(215, 231, 223)", +"hsl(180, 25%, 87.5%, 1.0)", "rgb(215, 231, 231)", +"hsl(210, 25%, 87.5%, 1.0)", "rgb(215, 223, 231)", +"hsl(240, 25%, 87.5%, 1.0)", "rgb(215, 215, 231)", +"hsl(270, 25%, 87.5%, 1.0)", "rgb(223, 215, 231)", +"hsl(300, 25%, 87.5%, 1.0)", "rgb(231, 215, 231)", +"hsl(330, 25%, 87.5%, 1.0)", "rgb(231, 215, 223)", +"hsl(0, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 211)", +"hsl(30, 37.5%, 87.5%, 1.0)", "rgb(235, 223, 211)", +"hsl(60, 37.5%, 87.5%, 1.0)", "rgb(235, 235, 211)", +"hsl(90, 37.5%, 87.5%, 1.0)", "rgb(223, 235, 211)", +"hsl(120, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 211)", +"hsl(150, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 223)", +"hsl(180, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 235)", +"hsl(210, 37.5%, 87.5%, 1.0)", "rgb(211, 223, 235)", +"hsl(240, 37.5%, 87.5%, 1.0)", "rgb(211, 211, 235)", +"hsl(270, 37.5%, 87.5%, 1.0)", "rgb(223, 211, 235)", +"hsl(300, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 235)", +"hsl(330, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 223)", +"hsl(0, 50%, 87.5%, 1.0)", "rgb(239, 207, 207)", +"hsl(30, 50%, 87.5%, 1.0)", "rgb(239, 223, 207)", +"hsl(60, 50%, 87.5%, 1.0)", "rgb(239, 239, 207)", +"hsl(90, 50%, 87.5%, 1.0)", "rgb(223, 239, 207)", +"hsl(120, 50%, 87.5%, 1.0)", "rgb(207, 239, 207)", +"hsl(150, 50%, 87.5%, 1.0)", "rgb(207, 239, 223)", +"hsl(180, 50%, 87.5%, 1.0)", "rgb(207, 239, 239)", +"hsl(210, 50%, 87.5%, 1.0)", "rgb(207, 223, 239)", +"hsl(240, 50%, 87.5%, 1.0)", "rgb(207, 207, 239)", +"hsl(270, 50%, 87.5%, 1.0)", "rgb(223, 207, 239)", +"hsl(300, 50%, 87.5%, 1.0)", "rgb(239, 207, 239)", +"hsl(330, 50%, 87.5%, 1.0)", "rgb(239, 207, 223)", +"hsl(0, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 203)", +"hsl(30, 62.5%, 87.5%, 1.0)", "rgb(243, 223, 203)", +"hsl(60, 62.5%, 87.5%, 1.0)", "rgb(243, 243, 203)", +"hsl(90, 62.5%, 87.5%, 1.0)", "rgb(223, 243, 203)", +"hsl(120, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 203)", +"hsl(150, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 223)", +"hsl(180, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 243)", +"hsl(210, 62.5%, 87.5%, 1.0)", "rgb(203, 223, 243)", +"hsl(240, 62.5%, 87.5%, 1.0)", "rgb(203, 203, 243)", +"hsl(270, 62.5%, 87.5%, 1.0)", "rgb(223, 203, 243)", +"hsl(300, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 243)", +"hsl(330, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 223)", +"hsl(0, 75%, 87.5%, 1.0)", "rgb(247, 199, 199)", +"hsl(30, 75%, 87.5%, 1.0)", "rgb(247, 223, 199)", +"hsl(60, 75%, 87.5%, 1.0)", "rgb(247, 247, 199)", +"hsl(90, 75%, 87.5%, 1.0)", "rgb(223, 247, 199)", +"hsl(120, 75%, 87.5%, 1.0)", "rgb(199, 247, 199)", +"hsl(150, 75%, 87.5%, 1.0)", "rgb(199, 247, 223)", +"hsl(180, 75%, 87.5%, 1.0)", "rgb(199, 247, 247)", +"hsl(210, 75%, 87.5%, 1.0)", "rgb(199, 223, 247)", +"hsl(240, 75%, 87.5%, 1.0)", "rgb(199, 199, 247)", +"hsl(270, 75%, 87.5%, 1.0)", "rgb(223, 199, 247)", +"hsl(300, 75%, 87.5%, 1.0)", "rgb(247, 199, 247)", +"hsl(330, 75%, 87.5%, 1.0)", "rgb(247, 199, 223)", +"hsl(0, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 195)", +"hsl(30, 87.5%, 87.5%, 1.0)", "rgb(251, 223, 195)", +"hsl(60, 87.5%, 87.5%, 1.0)", "rgb(251, 251, 195)", +"hsl(90, 87.5%, 87.5%, 1.0)", "rgb(223, 251, 195)", +"hsl(120, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 195)", +"hsl(150, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 223)", +"hsl(180, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 251)", +"hsl(210, 87.5%, 87.5%, 1.0)", "rgb(195, 223, 251)", +"hsl(240, 87.5%, 87.5%, 1.0)", "rgb(195, 195, 251)", +"hsl(270, 87.5%, 87.5%, 1.0)", "rgb(223, 195, 251)", +"hsl(300, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 251)", +"hsl(330, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 223)", +"hsl(0, 100%, 87.5%, 1.0)", "rgb(255, 191, 191)", +"hsl(30, 100%, 87.5%, 1.0)", "rgb(255, 223, 191)", +"hsl(60, 100%, 87.5%, 1.0)", "rgb(255, 255, 191)", +"hsl(90, 100%, 87.5%, 1.0)", "rgb(223, 255, 191)", +"hsl(120, 100%, 87.5%, 1.0)", "rgb(191, 255, 191)", +"hsl(150, 100%, 87.5%, 1.0)", "rgb(191, 255, 223)", +"hsl(180, 100%, 87.5%, 1.0)", "rgb(191, 255, 255)", +"hsl(210, 100%, 87.5%, 1.0)", "rgb(191, 223, 255)", +"hsl(240, 100%, 87.5%, 1.0)", "rgb(191, 191, 255)", +"hsl(270, 100%, 87.5%, 1.0)", "rgb(223, 191, 255)", +"hsl(300, 100%, 87.5%, 1.0)", "rgb(255, 191, 255)", +"hsl(330, 100%, 87.5%, 1.0)", "rgb(255, 191, 223)", +"hsl(0, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(30, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(60, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(90, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(120, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(150, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(180, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(210, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(240, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(270, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(300, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(330, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsl(0, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(30, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(60, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(90, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(120, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(150, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(180, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(210, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(240, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(270, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(300, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(330, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(0, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 28, 0.25)", +"hsl(30, 12.5%, 12.5%, 0.25)", "rgba(36, 32, 28, 0.25)", +"hsl(60, 12.5%, 12.5%, 0.25)", "rgba(36, 36, 28, 0.25)", +"hsl(90, 12.5%, 12.5%, 0.25)", "rgba(32, 36, 28, 0.25)", +"hsl(120, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 28, 0.25)", +"hsl(150, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 32, 0.25)", +"hsl(180, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 36, 0.25)", +"hsl(210, 12.5%, 12.5%, 0.25)", "rgba(28, 32, 36, 0.25)", +"hsl(240, 12.5%, 12.5%, 0.25)", "rgba(28, 28, 36, 0.25)", +"hsl(270, 12.5%, 12.5%, 0.25)", "rgba(32, 28, 36, 0.25)", +"hsl(300, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 36, 0.25)", +"hsl(330, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 32, 0.25)", +"hsl(0, 25%, 12.5%, 0.25)", "rgba(40, 24, 24, 0.25)", +"hsl(30, 25%, 12.5%, 0.25)", "rgba(40, 32, 24, 0.25)", +"hsl(60, 25%, 12.5%, 0.25)", "rgba(40, 40, 24, 0.25)", +"hsl(90, 25%, 12.5%, 0.25)", "rgba(32, 40, 24, 0.25)", +"hsl(120, 25%, 12.5%, 0.25)", "rgba(24, 40, 24, 0.25)", +"hsl(150, 25%, 12.5%, 0.25)", "rgba(24, 40, 32, 0.25)", +"hsl(180, 25%, 12.5%, 0.25)", "rgba(24, 40, 40, 0.25)", +"hsl(210, 25%, 12.5%, 0.25)", "rgba(24, 32, 40, 0.25)", +"hsl(240, 25%, 12.5%, 0.25)", "rgba(24, 24, 40, 0.25)", +"hsl(270, 25%, 12.5%, 0.25)", "rgba(32, 24, 40, 0.25)", +"hsl(300, 25%, 12.5%, 0.25)", "rgba(40, 24, 40, 0.25)", +"hsl(330, 25%, 12.5%, 0.25)", "rgba(40, 24, 32, 0.25)", +"hsl(0, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 20, 0.25)", +"hsl(30, 37.5%, 12.5%, 0.25)", "rgba(44, 32, 20, 0.25)", +"hsl(60, 37.5%, 12.5%, 0.25)", "rgba(44, 44, 20, 0.25)", +"hsl(90, 37.5%, 12.5%, 0.25)", "rgba(32, 44, 20, 0.25)", +"hsl(120, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 20, 0.25)", +"hsl(150, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 32, 0.25)", +"hsl(180, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 44, 0.25)", +"hsl(210, 37.5%, 12.5%, 0.25)", "rgba(20, 32, 44, 0.25)", +"hsl(240, 37.5%, 12.5%, 0.25)", "rgba(20, 20, 44, 0.25)", +"hsl(270, 37.5%, 12.5%, 0.25)", "rgba(32, 20, 44, 0.25)", +"hsl(300, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 44, 0.25)", +"hsl(330, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 32, 0.25)", +"hsl(0, 50%, 12.5%, 0.25)", "rgba(48, 16, 16, 0.25)", +"hsl(30, 50%, 12.5%, 0.25)", "rgba(48, 32, 16, 0.25)", +"hsl(60, 50%, 12.5%, 0.25)", "rgba(48, 48, 16, 0.25)", +"hsl(90, 50%, 12.5%, 0.25)", "rgba(32, 48, 16, 0.25)", +"hsl(120, 50%, 12.5%, 0.25)", "rgba(16, 48, 16, 0.25)", +"hsl(150, 50%, 12.5%, 0.25)", "rgba(16, 48, 32, 0.25)", +"hsl(180, 50%, 12.5%, 0.25)", "rgba(16, 48, 48, 0.25)", +"hsl(210, 50%, 12.5%, 0.25)", "rgba(16, 32, 48, 0.25)", +"hsl(240, 50%, 12.5%, 0.25)", "rgba(16, 16, 48, 0.25)", +"hsl(270, 50%, 12.5%, 0.25)", "rgba(32, 16, 48, 0.25)", +"hsl(300, 50%, 12.5%, 0.25)", "rgba(48, 16, 48, 0.25)", +"hsl(330, 50%, 12.5%, 0.25)", "rgba(48, 16, 32, 0.25)", +"hsl(0, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 12, 0.25)", +"hsl(30, 62.5%, 12.5%, 0.25)", "rgba(52, 32, 12, 0.25)", +"hsl(60, 62.5%, 12.5%, 0.25)", "rgba(52, 52, 12, 0.25)", +"hsl(90, 62.5%, 12.5%, 0.25)", "rgba(32, 52, 12, 0.25)", +"hsl(120, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 12, 0.25)", +"hsl(150, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 32, 0.25)", +"hsl(180, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 52, 0.25)", +"hsl(210, 62.5%, 12.5%, 0.25)", "rgba(12, 32, 52, 0.25)", +"hsl(240, 62.5%, 12.5%, 0.25)", "rgba(12, 12, 52, 0.25)", +"hsl(270, 62.5%, 12.5%, 0.25)", "rgba(32, 12, 52, 0.25)", +"hsl(300, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 52, 0.25)", +"hsl(330, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 32, 0.25)", +"hsl(0, 75%, 12.5%, 0.25)", "rgba(56, 8, 8, 0.25)", +"hsl(30, 75%, 12.5%, 0.25)", "rgba(56, 32, 8, 0.25)", +"hsl(60, 75%, 12.5%, 0.25)", "rgba(56, 56, 8, 0.25)", +"hsl(90, 75%, 12.5%, 0.25)", "rgba(32, 56, 8, 0.25)", +"hsl(120, 75%, 12.5%, 0.25)", "rgba(8, 56, 8, 0.25)", +"hsl(150, 75%, 12.5%, 0.25)", "rgba(8, 56, 32, 0.25)", +"hsl(180, 75%, 12.5%, 0.25)", "rgba(8, 56, 56, 0.25)", +"hsl(210, 75%, 12.5%, 0.25)", "rgba(8, 32, 56, 0.25)", +"hsl(240, 75%, 12.5%, 0.25)", "rgba(8, 8, 56, 0.25)", +"hsl(270, 75%, 12.5%, 0.25)", "rgba(32, 8, 56, 0.25)", +"hsl(300, 75%, 12.5%, 0.25)", "rgba(56, 8, 56, 0.25)", +"hsl(330, 75%, 12.5%, 0.25)", "rgba(56, 8, 32, 0.25)", +"hsl(0, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 4, 0.25)", +"hsl(30, 87.5%, 12.5%, 0.25)", "rgba(60, 32, 4, 0.25)", +"hsl(60, 87.5%, 12.5%, 0.25)", "rgba(60, 60, 4, 0.25)", +"hsl(90, 87.5%, 12.5%, 0.25)", "rgba(32, 60, 4, 0.25)", +"hsl(120, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 4, 0.25)", +"hsl(150, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 32, 0.25)", +"hsl(180, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 60, 0.25)", +"hsl(210, 87.5%, 12.5%, 0.25)", "rgba(4, 32, 60, 0.25)", +"hsl(240, 87.5%, 12.5%, 0.25)", "rgba(4, 4, 60, 0.25)", +"hsl(270, 87.5%, 12.5%, 0.25)", "rgba(32, 4, 60, 0.25)", +"hsl(300, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 60, 0.25)", +"hsl(330, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 32, 0.25)", +"hsl(0, 100%, 12.5%, 0.25)", "rgba(64, 0, 0, 0.25)", +"hsl(30, 100%, 12.5%, 0.25)", "rgba(64, 32, 0, 0.25)", +"hsl(60, 100%, 12.5%, 0.25)", "rgba(64, 64, 0, 0.25)", +"hsl(90, 100%, 12.5%, 0.25)", "rgba(32, 64, 0, 0.25)", +"hsl(120, 100%, 12.5%, 0.25)", "rgba(0, 64, 0, 0.25)", +"hsl(150, 100%, 12.5%, 0.25)", "rgba(0, 64, 32, 0.25)", +"hsl(180, 100%, 12.5%, 0.25)", "rgba(0, 64, 64, 0.25)", +"hsl(210, 100%, 12.5%, 0.25)", "rgba(0, 32, 64, 0.25)", +"hsl(240, 100%, 12.5%, 0.25)", "rgba(0, 0, 64, 0.25)", +"hsl(270, 100%, 12.5%, 0.25)", "rgba(32, 0, 64, 0.25)", +"hsl(300, 100%, 12.5%, 0.25)", "rgba(64, 0, 64, 0.25)", +"hsl(330, 100%, 12.5%, 0.25)", "rgba(64, 0, 32, 0.25)", +"hsl(0, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(30, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(60, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(90, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(120, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(150, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(180, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(210, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(240, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(270, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(300, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(330, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(0, 12.5%, 25%, 0.25)", "rgba(72, 56, 56, 0.25)", +"hsl(30, 12.5%, 25%, 0.25)", "rgba(72, 64, 56, 0.25)", +"hsl(60, 12.5%, 25%, 0.25)", "rgba(72, 72, 56, 0.25)", +"hsl(90, 12.5%, 25%, 0.25)", "rgba(64, 72, 56, 0.25)", +"hsl(120, 12.5%, 25%, 0.25)", "rgba(56, 72, 56, 0.25)", +"hsl(150, 12.5%, 25%, 0.25)", "rgba(56, 72, 64, 0.25)", +"hsl(180, 12.5%, 25%, 0.25)", "rgba(56, 72, 72, 0.25)", +"hsl(210, 12.5%, 25%, 0.25)", "rgba(56, 64, 72, 0.25)", +"hsl(240, 12.5%, 25%, 0.25)", "rgba(56, 56, 72, 0.25)", +"hsl(270, 12.5%, 25%, 0.25)", "rgba(64, 56, 72, 0.25)", +"hsl(300, 12.5%, 25%, 0.25)", "rgba(72, 56, 72, 0.25)", +"hsl(330, 12.5%, 25%, 0.25)", "rgba(72, 56, 64, 0.25)", +"hsl(0, 25%, 25%, 0.25)", "rgba(80, 48, 48, 0.25)", +"hsl(30, 25%, 25%, 0.25)", "rgba(80, 64, 48, 0.25)", +"hsl(60, 25%, 25%, 0.25)", "rgba(80, 80, 48, 0.25)", +"hsl(90, 25%, 25%, 0.25)", "rgba(64, 80, 48, 0.25)", +"hsl(120, 25%, 25%, 0.25)", "rgba(48, 80, 48, 0.25)", +"hsl(150, 25%, 25%, 0.25)", "rgba(48, 80, 64, 0.25)", +"hsl(180, 25%, 25%, 0.25)", "rgba(48, 80, 80, 0.25)", +"hsl(210, 25%, 25%, 0.25)", "rgba(48, 64, 80, 0.25)", +"hsl(240, 25%, 25%, 0.25)", "rgba(48, 48, 80, 0.25)", +"hsl(270, 25%, 25%, 0.25)", "rgba(64, 48, 80, 0.25)", +"hsl(300, 25%, 25%, 0.25)", "rgba(80, 48, 80, 0.25)", +"hsl(330, 25%, 25%, 0.25)", "rgba(80, 48, 64, 0.25)", +"hsl(0, 37.5%, 25%, 0.25)", "rgba(88, 40, 40, 0.25)", +"hsl(30, 37.5%, 25%, 0.25)", "rgba(88, 64, 40, 0.25)", +"hsl(60, 37.5%, 25%, 0.25)", "rgba(88, 88, 40, 0.25)", +"hsl(90, 37.5%, 25%, 0.25)", "rgba(64, 88, 40, 0.25)", +"hsl(120, 37.5%, 25%, 0.25)", "rgba(40, 88, 40, 0.25)", +"hsl(150, 37.5%, 25%, 0.25)", "rgba(40, 88, 64, 0.25)", +"hsl(180, 37.5%, 25%, 0.25)", "rgba(40, 88, 88, 0.25)", +"hsl(210, 37.5%, 25%, 0.25)", "rgba(40, 64, 88, 0.25)", +"hsl(240, 37.5%, 25%, 0.25)", "rgba(40, 40, 88, 0.25)", +"hsl(270, 37.5%, 25%, 0.25)", "rgba(64, 40, 88, 0.25)", +"hsl(300, 37.5%, 25%, 0.25)", "rgba(88, 40, 88, 0.25)", +"hsl(330, 37.5%, 25%, 0.25)", "rgba(88, 40, 64, 0.25)", +"hsl(0, 50%, 25%, 0.25)", "rgba(96, 32, 32, 0.25)", +"hsl(30, 50%, 25%, 0.25)", "rgba(96, 64, 32, 0.25)", +"hsl(60, 50%, 25%, 0.25)", "rgba(96, 96, 32, 0.25)", +"hsl(90, 50%, 25%, 0.25)", "rgba(64, 96, 32, 0.25)", +"hsl(120, 50%, 25%, 0.25)", "rgba(32, 96, 32, 0.25)", +"hsl(150, 50%, 25%, 0.25)", "rgba(32, 96, 64, 0.25)", +"hsl(180, 50%, 25%, 0.25)", "rgba(32, 96, 96, 0.25)", +"hsl(210, 50%, 25%, 0.25)", "rgba(32, 64, 96, 0.25)", +"hsl(240, 50%, 25%, 0.25)", "rgba(32, 32, 96, 0.25)", +"hsl(270, 50%, 25%, 0.25)", "rgba(64, 32, 96, 0.25)", +"hsl(300, 50%, 25%, 0.25)", "rgba(96, 32, 96, 0.25)", +"hsl(330, 50%, 25%, 0.25)", "rgba(96, 32, 64, 0.25)", +"hsl(0, 62.5%, 25%, 0.25)", "rgba(104, 24, 24, 0.25)", +"hsl(30, 62.5%, 25%, 0.25)", "rgba(104, 64, 24, 0.25)", +"hsl(60, 62.5%, 25%, 0.25)", "rgba(104, 104, 24, 0.25)", +"hsl(90, 62.5%, 25%, 0.25)", "rgba(64, 104, 24, 0.25)", +"hsl(120, 62.5%, 25%, 0.25)", "rgba(24, 104, 24, 0.25)", +"hsl(150, 62.5%, 25%, 0.25)", "rgba(24, 104, 64, 0.25)", +"hsl(180, 62.5%, 25%, 0.25)", "rgba(24, 104, 104, 0.25)", +"hsl(210, 62.5%, 25%, 0.25)", "rgba(24, 64, 104, 0.25)", +"hsl(240, 62.5%, 25%, 0.25)", "rgba(24, 24, 104, 0.25)", +"hsl(270, 62.5%, 25%, 0.25)", "rgba(64, 24, 104, 0.25)", +"hsl(300, 62.5%, 25%, 0.25)", "rgba(104, 24, 104, 0.25)", +"hsl(330, 62.5%, 25%, 0.25)", "rgba(104, 24, 64, 0.25)", +"hsl(0, 75%, 25%, 0.25)", "rgba(112, 16, 16, 0.25)", +"hsl(30, 75%, 25%, 0.25)", "rgba(112, 64, 16, 0.25)", +"hsl(60, 75%, 25%, 0.25)", "rgba(112, 112, 16, 0.25)", +"hsl(90, 75%, 25%, 0.25)", "rgba(64, 112, 16, 0.25)", +"hsl(120, 75%, 25%, 0.25)", "rgba(16, 112, 16, 0.25)", +"hsl(150, 75%, 25%, 0.25)", "rgba(16, 112, 64, 0.25)", +"hsl(180, 75%, 25%, 0.25)", "rgba(16, 112, 112, 0.25)", +"hsl(210, 75%, 25%, 0.25)", "rgba(16, 64, 112, 0.25)", +"hsl(240, 75%, 25%, 0.25)", "rgba(16, 16, 112, 0.25)", +"hsl(270, 75%, 25%, 0.25)", "rgba(64, 16, 112, 0.25)", +"hsl(300, 75%, 25%, 0.25)", "rgba(112, 16, 112, 0.25)", +"hsl(330, 75%, 25%, 0.25)", "rgba(112, 16, 64, 0.25)", +"hsl(0, 87.5%, 25%, 0.25)", "rgba(120, 8, 8, 0.25)", +"hsl(30, 87.5%, 25%, 0.25)", "rgba(120, 64, 8, 0.25)", +"hsl(60, 87.5%, 25%, 0.25)", "rgba(120, 120, 8, 0.25)", +"hsl(90, 87.5%, 25%, 0.25)", "rgba(64, 120, 8, 0.25)", +"hsl(120, 87.5%, 25%, 0.25)", "rgba(8, 120, 8, 0.25)", +"hsl(150, 87.5%, 25%, 0.25)", "rgba(8, 120, 64, 0.25)", +"hsl(180, 87.5%, 25%, 0.25)", "rgba(8, 120, 120, 0.25)", +"hsl(210, 87.5%, 25%, 0.25)", "rgba(8, 64, 120, 0.25)", +"hsl(240, 87.5%, 25%, 0.25)", "rgba(8, 8, 120, 0.25)", +"hsl(270, 87.5%, 25%, 0.25)", "rgba(64, 8, 120, 0.25)", +"hsl(300, 87.5%, 25%, 0.25)", "rgba(120, 8, 120, 0.25)", +"hsl(330, 87.5%, 25%, 0.25)", "rgba(120, 8, 64, 0.25)", +"hsl(0, 100%, 25%, 0.25)", "rgba(128, 0, 0, 0.25)", +"hsl(30, 100%, 25%, 0.25)", "rgba(128, 64, 0, 0.25)", +"hsl(60, 100%, 25%, 0.25)", "rgba(128, 128, 0, 0.25)", +"hsl(90, 100%, 25%, 0.25)", "rgba(64, 128, 0, 0.25)", +"hsl(120, 100%, 25%, 0.25)", "rgba(0, 128, 0, 0.25)", +"hsl(150, 100%, 25%, 0.25)", "rgba(0, 128, 64, 0.25)", +"hsl(180, 100%, 25%, 0.25)", "rgba(0, 128, 128, 0.25)", +"hsl(210, 100%, 25%, 0.25)", "rgba(0, 64, 128, 0.25)", +"hsl(240, 100%, 25%, 0.25)", "rgba(0, 0, 128, 0.25)", +"hsl(270, 100%, 25%, 0.25)", "rgba(64, 0, 128, 0.25)", +"hsl(300, 100%, 25%, 0.25)", "rgba(128, 0, 128, 0.25)", +"hsl(330, 100%, 25%, 0.25)", "rgba(128, 0, 64, 0.25)", +"hsl(0, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(30, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(60, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(90, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(120, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(150, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(180, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(210, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(240, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(270, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(300, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(330, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(0, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 84, 0.25)", +"hsl(30, 12.5%, 37.5%, 0.25)", "rgba(108, 96, 84, 0.25)", +"hsl(60, 12.5%, 37.5%, 0.25)", "rgba(108, 108, 84, 0.25)", +"hsl(90, 12.5%, 37.5%, 0.25)", "rgba(96, 108, 84, 0.25)", +"hsl(120, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 84, 0.25)", +"hsl(150, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 96, 0.25)", +"hsl(180, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 108, 0.25)", +"hsl(210, 12.5%, 37.5%, 0.25)", "rgba(84, 96, 108, 0.25)", +"hsl(240, 12.5%, 37.5%, 0.25)", "rgba(84, 84, 108, 0.25)", +"hsl(270, 12.5%, 37.5%, 0.25)", "rgba(96, 84, 108, 0.25)", +"hsl(300, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 108, 0.25)", +"hsl(330, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 96, 0.25)", +"hsl(0, 25%, 37.5%, 0.25)", "rgba(120, 72, 72, 0.25)", +"hsl(30, 25%, 37.5%, 0.25)", "rgba(120, 96, 72, 0.25)", +"hsl(60, 25%, 37.5%, 0.25)", "rgba(120, 120, 72, 0.25)", +"hsl(90, 25%, 37.5%, 0.25)", "rgba(96, 120, 72, 0.25)", +"hsl(120, 25%, 37.5%, 0.25)", "rgba(72, 120, 72, 0.25)", +"hsl(150, 25%, 37.5%, 0.25)", "rgba(72, 120, 96, 0.25)", +"hsl(180, 25%, 37.5%, 0.25)", "rgba(72, 120, 120, 0.25)", +"hsl(210, 25%, 37.5%, 0.25)", "rgba(72, 96, 120, 0.25)", +"hsl(240, 25%, 37.5%, 0.25)", "rgba(72, 72, 120, 0.25)", +"hsl(270, 25%, 37.5%, 0.25)", "rgba(96, 72, 120, 0.25)", +"hsl(300, 25%, 37.5%, 0.25)", "rgba(120, 72, 120, 0.25)", +"hsl(330, 25%, 37.5%, 0.25)", "rgba(120, 72, 96, 0.25)", +"hsl(0, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 60, 0.25)", +"hsl(30, 37.5%, 37.5%, 0.25)", "rgba(131, 96, 60, 0.25)", +"hsl(60, 37.5%, 37.5%, 0.25)", "rgba(131, 131, 60, 0.25)", +"hsl(90, 37.5%, 37.5%, 0.25)", "rgba(96, 131, 60, 0.25)", +"hsl(120, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 60, 0.25)", +"hsl(150, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 96, 0.25)", +"hsl(180, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 131, 0.25)", +"hsl(210, 37.5%, 37.5%, 0.25)", "rgba(60, 96, 131, 0.25)", +"hsl(240, 37.5%, 37.5%, 0.25)", "rgba(60, 60, 131, 0.25)", +"hsl(270, 37.5%, 37.5%, 0.25)", "rgba(96, 60, 131, 0.25)", +"hsl(300, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 131, 0.25)", +"hsl(330, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 96, 0.25)", +"hsl(0, 50%, 37.5%, 0.25)", "rgba(143, 48, 48, 0.25)", +"hsl(30, 50%, 37.5%, 0.25)", "rgba(143, 96, 48, 0.25)", +"hsl(60, 50%, 37.5%, 0.25)", "rgba(143, 143, 48, 0.25)", +"hsl(90, 50%, 37.5%, 0.25)", "rgba(96, 143, 48, 0.25)", +"hsl(120, 50%, 37.5%, 0.25)", "rgba(48, 143, 48, 0.25)", +"hsl(150, 50%, 37.5%, 0.25)", "rgba(48, 143, 96, 0.25)", +"hsl(180, 50%, 37.5%, 0.25)", "rgba(48, 143, 143, 0.25)", +"hsl(210, 50%, 37.5%, 0.25)", "rgba(48, 96, 143, 0.25)", +"hsl(240, 50%, 37.5%, 0.25)", "rgba(48, 48, 143, 0.25)", +"hsl(270, 50%, 37.5%, 0.25)", "rgba(96, 48, 143, 0.25)", +"hsl(300, 50%, 37.5%, 0.25)", "rgba(143, 48, 143, 0.25)", +"hsl(330, 50%, 37.5%, 0.25)", "rgba(143, 48, 96, 0.25)", +"hsl(0, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 36, 0.25)", +"hsl(30, 62.5%, 37.5%, 0.25)", "rgba(155, 96, 36, 0.25)", +"hsl(60, 62.5%, 37.5%, 0.25)", "rgba(155, 155, 36, 0.25)", +"hsl(90, 62.5%, 37.5%, 0.25)", "rgba(96, 155, 36, 0.25)", +"hsl(120, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 36, 0.25)", +"hsl(150, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 96, 0.25)", +"hsl(180, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 155, 0.25)", +"hsl(210, 62.5%, 37.5%, 0.25)", "rgba(36, 96, 155, 0.25)", +"hsl(240, 62.5%, 37.5%, 0.25)", "rgba(36, 36, 155, 0.25)", +"hsl(270, 62.5%, 37.5%, 0.25)", "rgba(96, 36, 155, 0.25)", +"hsl(300, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 155, 0.25)", +"hsl(330, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 96, 0.25)", +"hsl(0, 75%, 37.5%, 0.25)", "rgba(167, 24, 24, 0.25)", +"hsl(30, 75%, 37.5%, 0.25)", "rgba(167, 96, 24, 0.25)", +"hsl(60, 75%, 37.5%, 0.25)", "rgba(167, 167, 24, 0.25)", +"hsl(90, 75%, 37.5%, 0.25)", "rgba(96, 167, 24, 0.25)", +"hsl(120, 75%, 37.5%, 0.25)", "rgba(24, 167, 24, 0.25)", +"hsl(150, 75%, 37.5%, 0.25)", "rgba(24, 167, 96, 0.25)", +"hsl(180, 75%, 37.5%, 0.25)", "rgba(24, 167, 167, 0.25)", +"hsl(210, 75%, 37.5%, 0.25)", "rgba(24, 96, 167, 0.25)", +"hsl(240, 75%, 37.5%, 0.25)", "rgba(24, 24, 167, 0.25)", +"hsl(270, 75%, 37.5%, 0.25)", "rgba(96, 24, 167, 0.25)", +"hsl(300, 75%, 37.5%, 0.25)", "rgba(167, 24, 167, 0.25)", +"hsl(330, 75%, 37.5%, 0.25)", "rgba(167, 24, 96, 0.25)", +"hsl(0, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 12, 0.25)", +"hsl(30, 87.5%, 37.5%, 0.25)", "rgba(179, 96, 12, 0.25)", +"hsl(60, 87.5%, 37.5%, 0.25)", "rgba(179, 179, 12, 0.25)", +"hsl(90, 87.5%, 37.5%, 0.25)", "rgba(96, 179, 12, 0.25)", +"hsl(120, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 12, 0.25)", +"hsl(150, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 96, 0.25)", +"hsl(180, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 179, 0.25)", +"hsl(210, 87.5%, 37.5%, 0.25)", "rgba(12, 96, 179, 0.25)", +"hsl(240, 87.5%, 37.5%, 0.25)", "rgba(12, 12, 179, 0.25)", +"hsl(270, 87.5%, 37.5%, 0.25)", "rgba(96, 12, 179, 0.25)", +"hsl(300, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 179, 0.25)", +"hsl(330, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 96, 0.25)", +"hsl(0, 100%, 37.5%, 0.25)", "rgba(191, 0, 0, 0.25)", +"hsl(30, 100%, 37.5%, 0.25)", "rgba(191, 96, 0, 0.25)", +"hsl(60, 100%, 37.5%, 0.25)", "rgba(191, 191, 0, 0.25)", +"hsl(90, 100%, 37.5%, 0.25)", "rgba(96, 191, 0, 0.25)", +"hsl(120, 100%, 37.5%, 0.25)", "rgba(0, 191, 0, 0.25)", +"hsl(150, 100%, 37.5%, 0.25)", "rgba(0, 191, 96, 0.25)", +"hsl(180, 100%, 37.5%, 0.25)", "rgba(0, 191, 191, 0.25)", +"hsl(210, 100%, 37.5%, 0.25)", "rgba(0, 96, 191, 0.25)", +"hsl(240, 100%, 37.5%, 0.25)", "rgba(0, 0, 191, 0.25)", +"hsl(270, 100%, 37.5%, 0.25)", "rgba(96, 0, 191, 0.25)", +"hsl(300, 100%, 37.5%, 0.25)", "rgba(191, 0, 191, 0.25)", +"hsl(330, 100%, 37.5%, 0.25)", "rgba(191, 0, 96, 0.25)", +"hsl(0, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(30, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(60, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(90, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(120, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(150, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(180, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(210, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(240, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(270, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(300, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(330, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(0, 12.5%, 50%, 0.25)", "rgba(143, 112, 112, 0.25)", +"hsl(30, 12.5%, 50%, 0.25)", "rgba(143, 128, 112, 0.25)", +"hsl(60, 12.5%, 50%, 0.25)", "rgba(143, 143, 112, 0.25)", +"hsl(90, 12.5%, 50%, 0.25)", "rgba(128, 143, 112, 0.25)", +"hsl(120, 12.5%, 50%, 0.25)", "rgba(112, 143, 112, 0.25)", +"hsl(150, 12.5%, 50%, 0.25)", "rgba(112, 143, 128, 0.25)", +"hsl(180, 12.5%, 50%, 0.25)", "rgba(112, 143, 143, 0.25)", +"hsl(210, 12.5%, 50%, 0.25)", "rgba(112, 128, 143, 0.25)", +"hsl(240, 12.5%, 50%, 0.25)", "rgba(112, 112, 143, 0.25)", +"hsl(270, 12.5%, 50%, 0.25)", "rgba(128, 112, 143, 0.25)", +"hsl(300, 12.5%, 50%, 0.25)", "rgba(143, 112, 143, 0.25)", +"hsl(330, 12.5%, 50%, 0.25)", "rgba(143, 112, 128, 0.25)", +"hsl(0, 25%, 50%, 0.25)", "rgba(159, 96, 96, 0.25)", +"hsl(30, 25%, 50%, 0.25)", "rgba(159, 128, 96, 0.25)", +"hsl(60, 25%, 50%, 0.25)", "rgba(159, 159, 96, 0.25)", +"hsl(90, 25%, 50%, 0.25)", "rgba(128, 159, 96, 0.25)", +"hsl(120, 25%, 50%, 0.25)", "rgba(96, 159, 96, 0.25)", +"hsl(150, 25%, 50%, 0.25)", "rgba(96, 159, 128, 0.25)", +"hsl(180, 25%, 50%, 0.25)", "rgba(96, 159, 159, 0.25)", +"hsl(210, 25%, 50%, 0.25)", "rgba(96, 128, 159, 0.25)", +"hsl(240, 25%, 50%, 0.25)", "rgba(96, 96, 159, 0.25)", +"hsl(270, 25%, 50%, 0.25)", "rgba(128, 96, 159, 0.25)", +"hsl(300, 25%, 50%, 0.25)", "rgba(159, 96, 159, 0.25)", +"hsl(330, 25%, 50%, 0.25)", "rgba(159, 96, 128, 0.25)", +"hsl(0, 37.5%, 50%, 0.25)", "rgba(175, 80, 80, 0.25)", +"hsl(30, 37.5%, 50%, 0.25)", "rgba(175, 128, 80, 0.25)", +"hsl(60, 37.5%, 50%, 0.25)", "rgba(175, 175, 80, 0.25)", +"hsl(90, 37.5%, 50%, 0.25)", "rgba(128, 175, 80, 0.25)", +"hsl(120, 37.5%, 50%, 0.25)", "rgba(80, 175, 80, 0.25)", +"hsl(150, 37.5%, 50%, 0.25)", "rgba(80, 175, 128, 0.25)", +"hsl(180, 37.5%, 50%, 0.25)", "rgba(80, 175, 175, 0.25)", +"hsl(210, 37.5%, 50%, 0.25)", "rgba(80, 128, 175, 0.25)", +"hsl(240, 37.5%, 50%, 0.25)", "rgba(80, 80, 175, 0.25)", +"hsl(270, 37.5%, 50%, 0.25)", "rgba(128, 80, 175, 0.25)", +"hsl(300, 37.5%, 50%, 0.25)", "rgba(175, 80, 175, 0.25)", +"hsl(330, 37.5%, 50%, 0.25)", "rgba(175, 80, 128, 0.25)", +"hsl(0, 50%, 50%, 0.25)", "rgba(191, 64, 64, 0.25)", +"hsl(30, 50%, 50%, 0.25)", "rgba(191, 128, 64, 0.25)", +"hsl(60, 50%, 50%, 0.25)", "rgba(191, 191, 64, 0.25)", +"hsl(90, 50%, 50%, 0.25)", "rgba(128, 191, 64, 0.25)", +"hsl(120, 50%, 50%, 0.25)", "rgba(64, 191, 64, 0.25)", +"hsl(150, 50%, 50%, 0.25)", "rgba(64, 191, 128, 0.25)", +"hsl(180, 50%, 50%, 0.25)", "rgba(64, 191, 191, 0.25)", +"hsl(210, 50%, 50%, 0.25)", "rgba(64, 128, 191, 0.25)", +"hsl(240, 50%, 50%, 0.25)", "rgba(64, 64, 191, 0.25)", +"hsl(270, 50%, 50%, 0.25)", "rgba(128, 64, 191, 0.25)", +"hsl(300, 50%, 50%, 0.25)", "rgba(191, 64, 191, 0.25)", +"hsl(330, 50%, 50%, 0.25)", "rgba(191, 64, 128, 0.25)", +"hsl(0, 62.5%, 50%, 0.25)", "rgba(207, 48, 48, 0.25)", +"hsl(30, 62.5%, 50%, 0.25)", "rgba(207, 128, 48, 0.25)", +"hsl(60, 62.5%, 50%, 0.25)", "rgba(207, 207, 48, 0.25)", +"hsl(90, 62.5%, 50%, 0.25)", "rgba(128, 207, 48, 0.25)", +"hsl(120, 62.5%, 50%, 0.25)", "rgba(48, 207, 48, 0.25)", +"hsl(150, 62.5%, 50%, 0.25)", "rgba(48, 207, 128, 0.25)", +"hsl(180, 62.5%, 50%, 0.25)", "rgba(48, 207, 207, 0.25)", +"hsl(210, 62.5%, 50%, 0.25)", "rgba(48, 128, 207, 0.25)", +"hsl(240, 62.5%, 50%, 0.25)", "rgba(48, 48, 207, 0.25)", +"hsl(270, 62.5%, 50%, 0.25)", "rgba(128, 48, 207, 0.25)", +"hsl(300, 62.5%, 50%, 0.25)", "rgba(207, 48, 207, 0.25)", +"hsl(330, 62.5%, 50%, 0.25)", "rgba(207, 48, 128, 0.25)", +"hsl(0, 75%, 50%, 0.25)", "rgba(223, 32, 32, 0.25)", +"hsl(30, 75%, 50%, 0.25)", "rgba(223, 128, 32, 0.25)", +"hsl(60, 75%, 50%, 0.25)", "rgba(223, 223, 32, 0.25)", +"hsl(90, 75%, 50%, 0.25)", "rgba(128, 223, 32, 0.25)", +"hsl(120, 75%, 50%, 0.25)", "rgba(32, 223, 32, 0.25)", +"hsl(150, 75%, 50%, 0.25)", "rgba(32, 223, 128, 0.25)", +"hsl(180, 75%, 50%, 0.25)", "rgba(32, 223, 223, 0.25)", +"hsl(210, 75%, 50%, 0.25)", "rgba(32, 128, 223, 0.25)", +"hsl(240, 75%, 50%, 0.25)", "rgba(32, 32, 223, 0.25)", +"hsl(270, 75%, 50%, 0.25)", "rgba(128, 32, 223, 0.25)", +"hsl(300, 75%, 50%, 0.25)", "rgba(223, 32, 223, 0.25)", +"hsl(330, 75%, 50%, 0.25)", "rgba(223, 32, 128, 0.25)", +"hsl(0, 87.5%, 50%, 0.25)", "rgba(239, 16, 16, 0.25)", +"hsl(30, 87.5%, 50%, 0.25)", "rgba(239, 128, 16, 0.25)", +"hsl(60, 87.5%, 50%, 0.25)", "rgba(239, 239, 16, 0.25)", +"hsl(90, 87.5%, 50%, 0.25)", "rgba(128, 239, 16, 0.25)", +"hsl(120, 87.5%, 50%, 0.25)", "rgba(16, 239, 16, 0.25)", +"hsl(150, 87.5%, 50%, 0.25)", "rgba(16, 239, 128, 0.25)", +"hsl(180, 87.5%, 50%, 0.25)", "rgba(16, 239, 239, 0.25)", +"hsl(210, 87.5%, 50%, 0.25)", "rgba(16, 128, 239, 0.25)", +"hsl(240, 87.5%, 50%, 0.25)", "rgba(16, 16, 239, 0.25)", +"hsl(270, 87.5%, 50%, 0.25)", "rgba(128, 16, 239, 0.25)", +"hsl(300, 87.5%, 50%, 0.25)", "rgba(239, 16, 239, 0.25)", +"hsl(330, 87.5%, 50%, 0.25)", "rgba(239, 16, 128, 0.25)", +"hsl(0, 100%, 50%, 0.25)", "rgba(255, 0, 0, 0.25)", +"hsl(30, 100%, 50%, 0.25)", "rgba(255, 128, 0, 0.25)", +"hsl(60, 100%, 50%, 0.25)", "rgba(255, 255, 0, 0.25)", +"hsl(90, 100%, 50%, 0.25)", "rgba(128, 255, 0, 0.25)", +"hsl(120, 100%, 50%, 0.25)", "rgba(0, 255, 0, 0.25)", +"hsl(150, 100%, 50%, 0.25)", "rgba(0, 255, 128, 0.25)", +"hsl(180, 100%, 50%, 0.25)", "rgba(0, 255, 255, 0.25)", +"hsl(210, 100%, 50%, 0.25)", "rgba(0, 128, 255, 0.25)", +"hsl(240, 100%, 50%, 0.25)", "rgba(0, 0, 255, 0.25)", +"hsl(270, 100%, 50%, 0.25)", "rgba(128, 0, 255, 0.25)", +"hsl(300, 100%, 50%, 0.25)", "rgba(255, 0, 255, 0.25)", +"hsl(330, 100%, 50%, 0.25)", "rgba(255, 0, 128, 0.25)", +"hsl(0, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(30, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(60, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(90, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(120, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(150, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(180, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(210, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(240, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(270, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(300, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(330, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(0, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 147, 0.25)", +"hsl(30, 12.5%, 62.5%, 0.25)", "rgba(171, 159, 147, 0.25)", +"hsl(60, 12.5%, 62.5%, 0.25)", "rgba(171, 171, 147, 0.25)", +"hsl(90, 12.5%, 62.5%, 0.25)", "rgba(159, 171, 147, 0.25)", +"hsl(120, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 147, 0.25)", +"hsl(150, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 159, 0.25)", +"hsl(180, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 171, 0.25)", +"hsl(210, 12.5%, 62.5%, 0.25)", "rgba(147, 159, 171, 0.25)", +"hsl(240, 12.5%, 62.5%, 0.25)", "rgba(147, 147, 171, 0.25)", +"hsl(270, 12.5%, 62.5%, 0.25)", "rgba(159, 147, 171, 0.25)", +"hsl(300, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 171, 0.25)", +"hsl(330, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 159, 0.25)", +"hsl(0, 25%, 62.5%, 0.25)", "rgba(183, 135, 135, 0.25)", +"hsl(30, 25%, 62.5%, 0.25)", "rgba(183, 159, 135, 0.25)", +"hsl(60, 25%, 62.5%, 0.25)", "rgba(183, 183, 135, 0.25)", +"hsl(90, 25%, 62.5%, 0.25)", "rgba(159, 183, 135, 0.25)", +"hsl(120, 25%, 62.5%, 0.25)", "rgba(135, 183, 135, 0.25)", +"hsl(150, 25%, 62.5%, 0.25)", "rgba(135, 183, 159, 0.25)", +"hsl(180, 25%, 62.5%, 0.25)", "rgba(135, 183, 183, 0.25)", +"hsl(210, 25%, 62.5%, 0.25)", "rgba(135, 159, 183, 0.25)", +"hsl(240, 25%, 62.5%, 0.25)", "rgba(135, 135, 183, 0.25)", +"hsl(270, 25%, 62.5%, 0.25)", "rgba(159, 135, 183, 0.25)", +"hsl(300, 25%, 62.5%, 0.25)", "rgba(183, 135, 183, 0.25)", +"hsl(330, 25%, 62.5%, 0.25)", "rgba(183, 135, 159, 0.25)", +"hsl(0, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 124, 0.25)", +"hsl(30, 37.5%, 62.5%, 0.25)", "rgba(195, 159, 124, 0.25)", +"hsl(60, 37.5%, 62.5%, 0.25)", "rgba(195, 195, 124, 0.25)", +"hsl(90, 37.5%, 62.5%, 0.25)", "rgba(159, 195, 124, 0.25)", +"hsl(120, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 124, 0.25)", +"hsl(150, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 159, 0.25)", +"hsl(180, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 195, 0.25)", +"hsl(210, 37.5%, 62.5%, 0.25)", "rgba(124, 159, 195, 0.25)", +"hsl(240, 37.5%, 62.5%, 0.25)", "rgba(124, 124, 195, 0.25)", +"hsl(270, 37.5%, 62.5%, 0.25)", "rgba(159, 124, 195, 0.25)", +"hsl(300, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 195, 0.25)", +"hsl(330, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 159, 0.25)", +"hsl(0, 50%, 62.5%, 0.25)", "rgba(207, 112, 112, 0.25)", +"hsl(30, 50%, 62.5%, 0.25)", "rgba(207, 159, 112, 0.25)", +"hsl(60, 50%, 62.5%, 0.25)", "rgba(207, 207, 112, 0.25)", +"hsl(90, 50%, 62.5%, 0.25)", "rgba(159, 207, 112, 0.25)", +"hsl(120, 50%, 62.5%, 0.25)", "rgba(112, 207, 112, 0.25)", +"hsl(150, 50%, 62.5%, 0.25)", "rgba(112, 207, 159, 0.25)", +"hsl(180, 50%, 62.5%, 0.25)", "rgba(112, 207, 207, 0.25)", +"hsl(210, 50%, 62.5%, 0.25)", "rgba(112, 159, 207, 0.25)", +"hsl(240, 50%, 62.5%, 0.25)", "rgba(112, 112, 207, 0.25)", +"hsl(270, 50%, 62.5%, 0.25)", "rgba(159, 112, 207, 0.25)", +"hsl(300, 50%, 62.5%, 0.25)", "rgba(207, 112, 207, 0.25)", +"hsl(330, 50%, 62.5%, 0.25)", "rgba(207, 112, 159, 0.25)", +"hsl(0, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 100, 0.25)", +"hsl(30, 62.5%, 62.5%, 0.25)", "rgba(219, 159, 100, 0.25)", +"hsl(60, 62.5%, 62.5%, 0.25)", "rgba(219, 219, 100, 0.25)", +"hsl(90, 62.5%, 62.5%, 0.25)", "rgba(159, 219, 100, 0.25)", +"hsl(120, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 100, 0.25)", +"hsl(150, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 159, 0.25)", +"hsl(180, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 219, 0.25)", +"hsl(210, 62.5%, 62.5%, 0.25)", "rgba(100, 159, 219, 0.25)", +"hsl(240, 62.5%, 62.5%, 0.25)", "rgba(100, 100, 219, 0.25)", +"hsl(270, 62.5%, 62.5%, 0.25)", "rgba(159, 100, 219, 0.25)", +"hsl(300, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 219, 0.25)", +"hsl(330, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 159, 0.25)", +"hsl(0, 75%, 62.5%, 0.25)", "rgba(231, 88, 88, 0.25)", +"hsl(30, 75%, 62.5%, 0.25)", "rgba(231, 159, 88, 0.25)", +"hsl(60, 75%, 62.5%, 0.25)", "rgba(231, 231, 88, 0.25)", +"hsl(90, 75%, 62.5%, 0.25)", "rgba(159, 231, 88, 0.25)", +"hsl(120, 75%, 62.5%, 0.25)", "rgba(88, 231, 88, 0.25)", +"hsl(150, 75%, 62.5%, 0.25)", "rgba(88, 231, 159, 0.25)", +"hsl(180, 75%, 62.5%, 0.25)", "rgba(88, 231, 231, 0.25)", +"hsl(210, 75%, 62.5%, 0.25)", "rgba(88, 159, 231, 0.25)", +"hsl(240, 75%, 62.5%, 0.25)", "rgba(88, 88, 231, 0.25)", +"hsl(270, 75%, 62.5%, 0.25)", "rgba(159, 88, 231, 0.25)", +"hsl(300, 75%, 62.5%, 0.25)", "rgba(231, 88, 231, 0.25)", +"hsl(330, 75%, 62.5%, 0.25)", "rgba(231, 88, 159, 0.25)", +"hsl(0, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 76, 0.25)", +"hsl(30, 87.5%, 62.5%, 0.25)", "rgba(243, 159, 76, 0.25)", +"hsl(60, 87.5%, 62.5%, 0.25)", "rgba(243, 243, 76, 0.25)", +"hsl(90, 87.5%, 62.5%, 0.25)", "rgba(159, 243, 76, 0.25)", +"hsl(120, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 76, 0.25)", +"hsl(150, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 159, 0.25)", +"hsl(180, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 243, 0.25)", +"hsl(210, 87.5%, 62.5%, 0.25)", "rgba(76, 159, 243, 0.25)", +"hsl(240, 87.5%, 62.5%, 0.25)", "rgba(76, 76, 243, 0.25)", +"hsl(270, 87.5%, 62.5%, 0.25)", "rgba(159, 76, 243, 0.25)", +"hsl(300, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 243, 0.25)", +"hsl(330, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 159, 0.25)", +"hsl(0, 100%, 62.5%, 0.25)", "rgba(255, 64, 64, 0.25)", +"hsl(30, 100%, 62.5%, 0.25)", "rgba(255, 159, 64, 0.25)", +"hsl(60, 100%, 62.5%, 0.25)", "rgba(255, 255, 64, 0.25)", +"hsl(90, 100%, 62.5%, 0.25)", "rgba(159, 255, 64, 0.25)", +"hsl(120, 100%, 62.5%, 0.25)", "rgba(64, 255, 64, 0.25)", +"hsl(150, 100%, 62.5%, 0.25)", "rgba(64, 255, 159, 0.25)", +"hsl(180, 100%, 62.5%, 0.25)", "rgba(64, 255, 255, 0.25)", +"hsl(210, 100%, 62.5%, 0.25)", "rgba(64, 159, 255, 0.25)", +"hsl(240, 100%, 62.5%, 0.25)", "rgba(64, 64, 255, 0.25)", +"hsl(270, 100%, 62.5%, 0.25)", "rgba(159, 64, 255, 0.25)", +"hsl(300, 100%, 62.5%, 0.25)", "rgba(255, 64, 255, 0.25)", +"hsl(330, 100%, 62.5%, 0.25)", "rgba(255, 64, 159, 0.25)", +"hsl(0, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(30, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(60, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(90, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(120, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(150, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(180, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(210, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(240, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(270, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(300, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(330, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(0, 12.5%, 75%, 0.25)", "rgba(199, 183, 183, 0.25)", +"hsl(30, 12.5%, 75%, 0.25)", "rgba(199, 191, 183, 0.25)", +"hsl(60, 12.5%, 75%, 0.25)", "rgba(199, 199, 183, 0.25)", +"hsl(90, 12.5%, 75%, 0.25)", "rgba(191, 199, 183, 0.25)", +"hsl(120, 12.5%, 75%, 0.25)", "rgba(183, 199, 183, 0.25)", +"hsl(150, 12.5%, 75%, 0.25)", "rgba(183, 199, 191, 0.25)", +"hsl(180, 12.5%, 75%, 0.25)", "rgba(183, 199, 199, 0.25)", +"hsl(210, 12.5%, 75%, 0.25)", "rgba(183, 191, 199, 0.25)", +"hsl(240, 12.5%, 75%, 0.25)", "rgba(183, 183, 199, 0.25)", +"hsl(270, 12.5%, 75%, 0.25)", "rgba(191, 183, 199, 0.25)", +"hsl(300, 12.5%, 75%, 0.25)", "rgba(199, 183, 199, 0.25)", +"hsl(330, 12.5%, 75%, 0.25)", "rgba(199, 183, 191, 0.25)", +"hsl(0, 25%, 75%, 0.25)", "rgba(207, 175, 175, 0.25)", +"hsl(30, 25%, 75%, 0.25)", "rgba(207, 191, 175, 0.25)", +"hsl(60, 25%, 75%, 0.25)", "rgba(207, 207, 175, 0.25)", +"hsl(90, 25%, 75%, 0.25)", "rgba(191, 207, 175, 0.25)", +"hsl(120, 25%, 75%, 0.25)", "rgba(175, 207, 175, 0.25)", +"hsl(150, 25%, 75%, 0.25)", "rgba(175, 207, 191, 0.25)", +"hsl(180, 25%, 75%, 0.25)", "rgba(175, 207, 207, 0.25)", +"hsl(210, 25%, 75%, 0.25)", "rgba(175, 191, 207, 0.25)", +"hsl(240, 25%, 75%, 0.25)", "rgba(175, 175, 207, 0.25)", +"hsl(270, 25%, 75%, 0.25)", "rgba(191, 175, 207, 0.25)", +"hsl(300, 25%, 75%, 0.25)", "rgba(207, 175, 207, 0.25)", +"hsl(330, 25%, 75%, 0.25)", "rgba(207, 175, 191, 0.25)", +"hsl(0, 37.5%, 75%, 0.25)", "rgba(215, 167, 167, 0.25)", +"hsl(30, 37.5%, 75%, 0.25)", "rgba(215, 191, 167, 0.25)", +"hsl(60, 37.5%, 75%, 0.25)", "rgba(215, 215, 167, 0.25)", +"hsl(90, 37.5%, 75%, 0.25)", "rgba(191, 215, 167, 0.25)", +"hsl(120, 37.5%, 75%, 0.25)", "rgba(167, 215, 167, 0.25)", +"hsl(150, 37.5%, 75%, 0.25)", "rgba(167, 215, 191, 0.25)", +"hsl(180, 37.5%, 75%, 0.25)", "rgba(167, 215, 215, 0.25)", +"hsl(210, 37.5%, 75%, 0.25)", "rgba(167, 191, 215, 0.25)", +"hsl(240, 37.5%, 75%, 0.25)", "rgba(167, 167, 215, 0.25)", +"hsl(270, 37.5%, 75%, 0.25)", "rgba(191, 167, 215, 0.25)", +"hsl(300, 37.5%, 75%, 0.25)", "rgba(215, 167, 215, 0.25)", +"hsl(330, 37.5%, 75%, 0.25)", "rgba(215, 167, 191, 0.25)", +"hsl(0, 50%, 75%, 0.25)", "rgba(223, 159, 159, 0.25)", +"hsl(30, 50%, 75%, 0.25)", "rgba(223, 191, 159, 0.25)", +"hsl(60, 50%, 75%, 0.25)", "rgba(223, 223, 159, 0.25)", +"hsl(90, 50%, 75%, 0.25)", "rgba(191, 223, 159, 0.25)", +"hsl(120, 50%, 75%, 0.25)", "rgba(159, 223, 159, 0.25)", +"hsl(150, 50%, 75%, 0.25)", "rgba(159, 223, 191, 0.25)", +"hsl(180, 50%, 75%, 0.25)", "rgba(159, 223, 223, 0.25)", +"hsl(210, 50%, 75%, 0.25)", "rgba(159, 191, 223, 0.25)", +"hsl(240, 50%, 75%, 0.25)", "rgba(159, 159, 223, 0.25)", +"hsl(270, 50%, 75%, 0.25)", "rgba(191, 159, 223, 0.25)", +"hsl(300, 50%, 75%, 0.25)", "rgba(223, 159, 223, 0.25)", +"hsl(330, 50%, 75%, 0.25)", "rgba(223, 159, 191, 0.25)", +"hsl(0, 62.5%, 75%, 0.25)", "rgba(231, 151, 151, 0.25)", +"hsl(30, 62.5%, 75%, 0.25)", "rgba(231, 191, 151, 0.25)", +"hsl(60, 62.5%, 75%, 0.25)", "rgba(231, 231, 151, 0.25)", +"hsl(90, 62.5%, 75%, 0.25)", "rgba(191, 231, 151, 0.25)", +"hsl(120, 62.5%, 75%, 0.25)", "rgba(151, 231, 151, 0.25)", +"hsl(150, 62.5%, 75%, 0.25)", "rgba(151, 231, 191, 0.25)", +"hsl(180, 62.5%, 75%, 0.25)", "rgba(151, 231, 231, 0.25)", +"hsl(210, 62.5%, 75%, 0.25)", "rgba(151, 191, 231, 0.25)", +"hsl(240, 62.5%, 75%, 0.25)", "rgba(151, 151, 231, 0.25)", +"hsl(270, 62.5%, 75%, 0.25)", "rgba(191, 151, 231, 0.25)", +"hsl(300, 62.5%, 75%, 0.25)", "rgba(231, 151, 231, 0.25)", +"hsl(330, 62.5%, 75%, 0.25)", "rgba(231, 151, 191, 0.25)", +"hsl(0, 75%, 75%, 0.25)", "rgba(239, 143, 143, 0.25)", +"hsl(30, 75%, 75%, 0.25)", "rgba(239, 191, 143, 0.25)", +"hsl(60, 75%, 75%, 0.25)", "rgba(239, 239, 143, 0.25)", +"hsl(90, 75%, 75%, 0.25)", "rgba(191, 239, 143, 0.25)", +"hsl(120, 75%, 75%, 0.25)", "rgba(143, 239, 143, 0.25)", +"hsl(150, 75%, 75%, 0.25)", "rgba(143, 239, 191, 0.25)", +"hsl(180, 75%, 75%, 0.25)", "rgba(143, 239, 239, 0.25)", +"hsl(210, 75%, 75%, 0.25)", "rgba(143, 191, 239, 0.25)", +"hsl(240, 75%, 75%, 0.25)", "rgba(143, 143, 239, 0.25)", +"hsl(270, 75%, 75%, 0.25)", "rgba(191, 143, 239, 0.25)", +"hsl(300, 75%, 75%, 0.25)", "rgba(239, 143, 239, 0.25)", +"hsl(330, 75%, 75%, 0.25)", "rgba(239, 143, 191, 0.25)", +"hsl(0, 87.5%, 75%, 0.25)", "rgba(247, 135, 135, 0.25)", +"hsl(30, 87.5%, 75%, 0.25)", "rgba(247, 191, 135, 0.25)", +"hsl(60, 87.5%, 75%, 0.25)", "rgba(247, 247, 135, 0.25)", +"hsl(90, 87.5%, 75%, 0.25)", "rgba(191, 247, 135, 0.25)", +"hsl(120, 87.5%, 75%, 0.25)", "rgba(135, 247, 135, 0.25)", +"hsl(150, 87.5%, 75%, 0.25)", "rgba(135, 247, 191, 0.25)", +"hsl(180, 87.5%, 75%, 0.25)", "rgba(135, 247, 247, 0.25)", +"hsl(210, 87.5%, 75%, 0.25)", "rgba(135, 191, 247, 0.25)", +"hsl(240, 87.5%, 75%, 0.25)", "rgba(135, 135, 247, 0.25)", +"hsl(270, 87.5%, 75%, 0.25)", "rgba(191, 135, 247, 0.25)", +"hsl(300, 87.5%, 75%, 0.25)", "rgba(247, 135, 247, 0.25)", +"hsl(330, 87.5%, 75%, 0.25)", "rgba(247, 135, 191, 0.25)", +"hsl(0, 100%, 75%, 0.25)", "rgba(255, 128, 128, 0.25)", +"hsl(30, 100%, 75%, 0.25)", "rgba(255, 191, 128, 0.25)", +"hsl(60, 100%, 75%, 0.25)", "rgba(255, 255, 128, 0.25)", +"hsl(90, 100%, 75%, 0.25)", "rgba(191, 255, 128, 0.25)", +"hsl(120, 100%, 75%, 0.25)", "rgba(128, 255, 128, 0.25)", +"hsl(150, 100%, 75%, 0.25)", "rgba(128, 255, 191, 0.25)", +"hsl(180, 100%, 75%, 0.25)", "rgba(128, 255, 255, 0.25)", +"hsl(210, 100%, 75%, 0.25)", "rgba(128, 191, 255, 0.25)", +"hsl(240, 100%, 75%, 0.25)", "rgba(128, 128, 255, 0.25)", +"hsl(270, 100%, 75%, 0.25)", "rgba(191, 128, 255, 0.25)", +"hsl(300, 100%, 75%, 0.25)", "rgba(255, 128, 255, 0.25)", +"hsl(330, 100%, 75%, 0.25)", "rgba(255, 128, 191, 0.25)", +"hsl(0, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(30, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(60, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(90, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(120, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(150, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(180, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(210, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(240, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(270, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(300, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(330, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(0, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 219, 0.25)", +"hsl(30, 12.5%, 87.5%, 0.25)", "rgba(227, 223, 219, 0.25)", +"hsl(60, 12.5%, 87.5%, 0.25)", "rgba(227, 227, 219, 0.25)", +"hsl(90, 12.5%, 87.5%, 0.25)", "rgba(223, 227, 219, 0.25)", +"hsl(120, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 219, 0.25)", +"hsl(150, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 223, 0.25)", +"hsl(180, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 227, 0.25)", +"hsl(210, 12.5%, 87.5%, 0.25)", "rgba(219, 223, 227, 0.25)", +"hsl(240, 12.5%, 87.5%, 0.25)", "rgba(219, 219, 227, 0.25)", +"hsl(270, 12.5%, 87.5%, 0.25)", "rgba(223, 219, 227, 0.25)", +"hsl(300, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 227, 0.25)", +"hsl(330, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 223, 0.25)", +"hsl(0, 25%, 87.5%, 0.25)", "rgba(231, 215, 215, 0.25)", +"hsl(30, 25%, 87.5%, 0.25)", "rgba(231, 223, 215, 0.25)", +"hsl(60, 25%, 87.5%, 0.25)", "rgba(231, 231, 215, 0.25)", +"hsl(90, 25%, 87.5%, 0.25)", "rgba(223, 231, 215, 0.25)", +"hsl(120, 25%, 87.5%, 0.25)", "rgba(215, 231, 215, 0.25)", +"hsl(150, 25%, 87.5%, 0.25)", "rgba(215, 231, 223, 0.25)", +"hsl(180, 25%, 87.5%, 0.25)", "rgba(215, 231, 231, 0.25)", +"hsl(210, 25%, 87.5%, 0.25)", "rgba(215, 223, 231, 0.25)", +"hsl(240, 25%, 87.5%, 0.25)", "rgba(215, 215, 231, 0.25)", +"hsl(270, 25%, 87.5%, 0.25)", "rgba(223, 215, 231, 0.25)", +"hsl(300, 25%, 87.5%, 0.25)", "rgba(231, 215, 231, 0.25)", +"hsl(330, 25%, 87.5%, 0.25)", "rgba(231, 215, 223, 0.25)", +"hsl(0, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 211, 0.25)", +"hsl(30, 37.5%, 87.5%, 0.25)", "rgba(235, 223, 211, 0.25)", +"hsl(60, 37.5%, 87.5%, 0.25)", "rgba(235, 235, 211, 0.25)", +"hsl(90, 37.5%, 87.5%, 0.25)", "rgba(223, 235, 211, 0.25)", +"hsl(120, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 211, 0.25)", +"hsl(150, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 223, 0.25)", +"hsl(180, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 235, 0.25)", +"hsl(210, 37.5%, 87.5%, 0.25)", "rgba(211, 223, 235, 0.25)", +"hsl(240, 37.5%, 87.5%, 0.25)", "rgba(211, 211, 235, 0.25)", +"hsl(270, 37.5%, 87.5%, 0.25)", "rgba(223, 211, 235, 0.25)", +"hsl(300, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 235, 0.25)", +"hsl(330, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 223, 0.25)", +"hsl(0, 50%, 87.5%, 0.25)", "rgba(239, 207, 207, 0.25)", +"hsl(30, 50%, 87.5%, 0.25)", "rgba(239, 223, 207, 0.25)", +"hsl(60, 50%, 87.5%, 0.25)", "rgba(239, 239, 207, 0.25)", +"hsl(90, 50%, 87.5%, 0.25)", "rgba(223, 239, 207, 0.25)", +"hsl(120, 50%, 87.5%, 0.25)", "rgba(207, 239, 207, 0.25)", +"hsl(150, 50%, 87.5%, 0.25)", "rgba(207, 239, 223, 0.25)", +"hsl(180, 50%, 87.5%, 0.25)", "rgba(207, 239, 239, 0.25)", +"hsl(210, 50%, 87.5%, 0.25)", "rgba(207, 223, 239, 0.25)", +"hsl(240, 50%, 87.5%, 0.25)", "rgba(207, 207, 239, 0.25)", +"hsl(270, 50%, 87.5%, 0.25)", "rgba(223, 207, 239, 0.25)", +"hsl(300, 50%, 87.5%, 0.25)", "rgba(239, 207, 239, 0.25)", +"hsl(330, 50%, 87.5%, 0.25)", "rgba(239, 207, 223, 0.25)", +"hsl(0, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 203, 0.25)", +"hsl(30, 62.5%, 87.5%, 0.25)", "rgba(243, 223, 203, 0.25)", +"hsl(60, 62.5%, 87.5%, 0.25)", "rgba(243, 243, 203, 0.25)", +"hsl(90, 62.5%, 87.5%, 0.25)", "rgba(223, 243, 203, 0.25)", +"hsl(120, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 203, 0.25)", +"hsl(150, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 223, 0.25)", +"hsl(180, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 243, 0.25)", +"hsl(210, 62.5%, 87.5%, 0.25)", "rgba(203, 223, 243, 0.25)", +"hsl(240, 62.5%, 87.5%, 0.25)", "rgba(203, 203, 243, 0.25)", +"hsl(270, 62.5%, 87.5%, 0.25)", "rgba(223, 203, 243, 0.25)", +"hsl(300, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 243, 0.25)", +"hsl(330, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 223, 0.25)", +"hsl(0, 75%, 87.5%, 0.25)", "rgba(247, 199, 199, 0.25)", +"hsl(30, 75%, 87.5%, 0.25)", "rgba(247, 223, 199, 0.25)", +"hsl(60, 75%, 87.5%, 0.25)", "rgba(247, 247, 199, 0.25)", +"hsl(90, 75%, 87.5%, 0.25)", "rgba(223, 247, 199, 0.25)", +"hsl(120, 75%, 87.5%, 0.25)", "rgba(199, 247, 199, 0.25)", +"hsl(150, 75%, 87.5%, 0.25)", "rgba(199, 247, 223, 0.25)", +"hsl(180, 75%, 87.5%, 0.25)", "rgba(199, 247, 247, 0.25)", +"hsl(210, 75%, 87.5%, 0.25)", "rgba(199, 223, 247, 0.25)", +"hsl(240, 75%, 87.5%, 0.25)", "rgba(199, 199, 247, 0.25)", +"hsl(270, 75%, 87.5%, 0.25)", "rgba(223, 199, 247, 0.25)", +"hsl(300, 75%, 87.5%, 0.25)", "rgba(247, 199, 247, 0.25)", +"hsl(330, 75%, 87.5%, 0.25)", "rgba(247, 199, 223, 0.25)", +"hsl(0, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 195, 0.25)", +"hsl(30, 87.5%, 87.5%, 0.25)", "rgba(251, 223, 195, 0.25)", +"hsl(60, 87.5%, 87.5%, 0.25)", "rgba(251, 251, 195, 0.25)", +"hsl(90, 87.5%, 87.5%, 0.25)", "rgba(223, 251, 195, 0.25)", +"hsl(120, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 195, 0.25)", +"hsl(150, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 223, 0.25)", +"hsl(180, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 251, 0.25)", +"hsl(210, 87.5%, 87.5%, 0.25)", "rgba(195, 223, 251, 0.25)", +"hsl(240, 87.5%, 87.5%, 0.25)", "rgba(195, 195, 251, 0.25)", +"hsl(270, 87.5%, 87.5%, 0.25)", "rgba(223, 195, 251, 0.25)", +"hsl(300, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 251, 0.25)", +"hsl(330, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 223, 0.25)", +"hsl(0, 100%, 87.5%, 0.25)", "rgba(255, 191, 191, 0.25)", +"hsl(30, 100%, 87.5%, 0.25)", "rgba(255, 223, 191, 0.25)", +"hsl(60, 100%, 87.5%, 0.25)", "rgba(255, 255, 191, 0.25)", +"hsl(90, 100%, 87.5%, 0.25)", "rgba(223, 255, 191, 0.25)", +"hsl(120, 100%, 87.5%, 0.25)", "rgba(191, 255, 191, 0.25)", +"hsl(150, 100%, 87.5%, 0.25)", "rgba(191, 255, 223, 0.25)", +"hsl(180, 100%, 87.5%, 0.25)", "rgba(191, 255, 255, 0.25)", +"hsl(210, 100%, 87.5%, 0.25)", "rgba(191, 223, 255, 0.25)", +"hsl(240, 100%, 87.5%, 0.25)", "rgba(191, 191, 255, 0.25)", +"hsl(270, 100%, 87.5%, 0.25)", "rgba(223, 191, 255, 0.25)", +"hsl(300, 100%, 87.5%, 0.25)", "rgba(255, 191, 255, 0.25)", +"hsl(330, 100%, 87.5%, 0.25)", "rgba(255, 191, 223, 0.25)", +"hsl(0, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(30, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(60, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(90, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(120, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(150, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(180, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(210, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(240, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(270, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(300, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(330, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsl(0, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 28, 0)", +"hsl(30, 12.5%, 12.5%, 0.0)", "rgba(36, 32, 28, 0)", +"hsl(60, 12.5%, 12.5%, 0.0)", "rgba(36, 36, 28, 0)", +"hsl(90, 12.5%, 12.5%, 0.0)", "rgba(32, 36, 28, 0)", +"hsl(120, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 28, 0)", +"hsl(150, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 32, 0)", +"hsl(180, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 36, 0)", +"hsl(210, 12.5%, 12.5%, 0.0)", "rgba(28, 32, 36, 0)", +"hsl(240, 12.5%, 12.5%, 0.0)", "rgba(28, 28, 36, 0)", +"hsl(270, 12.5%, 12.5%, 0.0)", "rgba(32, 28, 36, 0)", +"hsl(300, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 36, 0)", +"hsl(330, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 32, 0)", +"hsl(0, 25%, 12.5%, 0.0)", "rgba(40, 24, 24, 0)", +"hsl(30, 25%, 12.5%, 0.0)", "rgba(40, 32, 24, 0)", +"hsl(60, 25%, 12.5%, 0.0)", "rgba(40, 40, 24, 0)", +"hsl(90, 25%, 12.5%, 0.0)", "rgba(32, 40, 24, 0)", +"hsl(120, 25%, 12.5%, 0.0)", "rgba(24, 40, 24, 0)", +"hsl(150, 25%, 12.5%, 0.0)", "rgba(24, 40, 32, 0)", +"hsl(180, 25%, 12.5%, 0.0)", "rgba(24, 40, 40, 0)", +"hsl(210, 25%, 12.5%, 0.0)", "rgba(24, 32, 40, 0)", +"hsl(240, 25%, 12.5%, 0.0)", "rgba(24, 24, 40, 0)", +"hsl(270, 25%, 12.5%, 0.0)", "rgba(32, 24, 40, 0)", +"hsl(300, 25%, 12.5%, 0.0)", "rgba(40, 24, 40, 0)", +"hsl(330, 25%, 12.5%, 0.0)", "rgba(40, 24, 32, 0)", +"hsl(0, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 20, 0)", +"hsl(30, 37.5%, 12.5%, 0.0)", "rgba(44, 32, 20, 0)", +"hsl(60, 37.5%, 12.5%, 0.0)", "rgba(44, 44, 20, 0)", +"hsl(90, 37.5%, 12.5%, 0.0)", "rgba(32, 44, 20, 0)", +"hsl(120, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 20, 0)", +"hsl(150, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 32, 0)", +"hsl(180, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 44, 0)", +"hsl(210, 37.5%, 12.5%, 0.0)", "rgba(20, 32, 44, 0)", +"hsl(240, 37.5%, 12.5%, 0.0)", "rgba(20, 20, 44, 0)", +"hsl(270, 37.5%, 12.5%, 0.0)", "rgba(32, 20, 44, 0)", +"hsl(300, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 44, 0)", +"hsl(330, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 32, 0)", +"hsl(0, 50%, 12.5%, 0.0)", "rgba(48, 16, 16, 0)", +"hsl(30, 50%, 12.5%, 0.0)", "rgba(48, 32, 16, 0)", +"hsl(60, 50%, 12.5%, 0.0)", "rgba(48, 48, 16, 0)", +"hsl(90, 50%, 12.5%, 0.0)", "rgba(32, 48, 16, 0)", +"hsl(120, 50%, 12.5%, 0.0)", "rgba(16, 48, 16, 0)", +"hsl(150, 50%, 12.5%, 0.0)", "rgba(16, 48, 32, 0)", +"hsl(180, 50%, 12.5%, 0.0)", "rgba(16, 48, 48, 0)", +"hsl(210, 50%, 12.5%, 0.0)", "rgba(16, 32, 48, 0)", +"hsl(240, 50%, 12.5%, 0.0)", "rgba(16, 16, 48, 0)", +"hsl(270, 50%, 12.5%, 0.0)", "rgba(32, 16, 48, 0)", +"hsl(300, 50%, 12.5%, 0.0)", "rgba(48, 16, 48, 0)", +"hsl(330, 50%, 12.5%, 0.0)", "rgba(48, 16, 32, 0)", +"hsl(0, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 12, 0)", +"hsl(30, 62.5%, 12.5%, 0.0)", "rgba(52, 32, 12, 0)", +"hsl(60, 62.5%, 12.5%, 0.0)", "rgba(52, 52, 12, 0)", +"hsl(90, 62.5%, 12.5%, 0.0)", "rgba(32, 52, 12, 0)", +"hsl(120, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 12, 0)", +"hsl(150, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 32, 0)", +"hsl(180, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 52, 0)", +"hsl(210, 62.5%, 12.5%, 0.0)", "rgba(12, 32, 52, 0)", +"hsl(240, 62.5%, 12.5%, 0.0)", "rgba(12, 12, 52, 0)", +"hsl(270, 62.5%, 12.5%, 0.0)", "rgba(32, 12, 52, 0)", +"hsl(300, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 52, 0)", +"hsl(330, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 32, 0)", +"hsl(0, 75%, 12.5%, 0.0)", "rgba(56, 8, 8, 0)", +"hsl(30, 75%, 12.5%, 0.0)", "rgba(56, 32, 8, 0)", +"hsl(60, 75%, 12.5%, 0.0)", "rgba(56, 56, 8, 0)", +"hsl(90, 75%, 12.5%, 0.0)", "rgba(32, 56, 8, 0)", +"hsl(120, 75%, 12.5%, 0.0)", "rgba(8, 56, 8, 0)", +"hsl(150, 75%, 12.5%, 0.0)", "rgba(8, 56, 32, 0)", +"hsl(180, 75%, 12.5%, 0.0)", "rgba(8, 56, 56, 0)", +"hsl(210, 75%, 12.5%, 0.0)", "rgba(8, 32, 56, 0)", +"hsl(240, 75%, 12.5%, 0.0)", "rgba(8, 8, 56, 0)", +"hsl(270, 75%, 12.5%, 0.0)", "rgba(32, 8, 56, 0)", +"hsl(300, 75%, 12.5%, 0.0)", "rgba(56, 8, 56, 0)", +"hsl(330, 75%, 12.5%, 0.0)", "rgba(56, 8, 32, 0)", +"hsl(0, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 4, 0)", +"hsl(30, 87.5%, 12.5%, 0.0)", "rgba(60, 32, 4, 0)", +"hsl(60, 87.5%, 12.5%, 0.0)", "rgba(60, 60, 4, 0)", +"hsl(90, 87.5%, 12.5%, 0.0)", "rgba(32, 60, 4, 0)", +"hsl(120, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 4, 0)", +"hsl(150, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 32, 0)", +"hsl(180, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 60, 0)", +"hsl(210, 87.5%, 12.5%, 0.0)", "rgba(4, 32, 60, 0)", +"hsl(240, 87.5%, 12.5%, 0.0)", "rgba(4, 4, 60, 0)", +"hsl(270, 87.5%, 12.5%, 0.0)", "rgba(32, 4, 60, 0)", +"hsl(300, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 60, 0)", +"hsl(330, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 32, 0)", +"hsl(0, 100%, 12.5%, 0.0)", "rgba(64, 0, 0, 0)", +"hsl(30, 100%, 12.5%, 0.0)", "rgba(64, 32, 0, 0)", +"hsl(60, 100%, 12.5%, 0.0)", "rgba(64, 64, 0, 0)", +"hsl(90, 100%, 12.5%, 0.0)", "rgba(32, 64, 0, 0)", +"hsl(120, 100%, 12.5%, 0.0)", "rgba(0, 64, 0, 0)", +"hsl(150, 100%, 12.5%, 0.0)", "rgba(0, 64, 32, 0)", +"hsl(180, 100%, 12.5%, 0.0)", "rgba(0, 64, 64, 0)", +"hsl(210, 100%, 12.5%, 0.0)", "rgba(0, 32, 64, 0)", +"hsl(240, 100%, 12.5%, 0.0)", "rgba(0, 0, 64, 0)", +"hsl(270, 100%, 12.5%, 0.0)", "rgba(32, 0, 64, 0)", +"hsl(300, 100%, 12.5%, 0.0)", "rgba(64, 0, 64, 0)", +"hsl(330, 100%, 12.5%, 0.0)", "rgba(64, 0, 32, 0)", +"hsl(0, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(30, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(60, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(90, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(120, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(150, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(180, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(210, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(240, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(270, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(300, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(330, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsl(0, 12.5%, 25%, 0.0)", "rgba(72, 56, 56, 0)", +"hsl(30, 12.5%, 25%, 0.0)", "rgba(72, 64, 56, 0)", +"hsl(60, 12.5%, 25%, 0.0)", "rgba(72, 72, 56, 0)", +"hsl(90, 12.5%, 25%, 0.0)", "rgba(64, 72, 56, 0)", +"hsl(120, 12.5%, 25%, 0.0)", "rgba(56, 72, 56, 0)", +"hsl(150, 12.5%, 25%, 0.0)", "rgba(56, 72, 64, 0)", +"hsl(180, 12.5%, 25%, 0.0)", "rgba(56, 72, 72, 0)", +"hsl(210, 12.5%, 25%, 0.0)", "rgba(56, 64, 72, 0)", +"hsl(240, 12.5%, 25%, 0.0)", "rgba(56, 56, 72, 0)", +"hsl(270, 12.5%, 25%, 0.0)", "rgba(64, 56, 72, 0)", +"hsl(300, 12.5%, 25%, 0.0)", "rgba(72, 56, 72, 0)", +"hsl(330, 12.5%, 25%, 0.0)", "rgba(72, 56, 64, 0)", +"hsl(0, 25%, 25%, 0.0)", "rgba(80, 48, 48, 0)", +"hsl(30, 25%, 25%, 0.0)", "rgba(80, 64, 48, 0)", +"hsl(60, 25%, 25%, 0.0)", "rgba(80, 80, 48, 0)", +"hsl(90, 25%, 25%, 0.0)", "rgba(64, 80, 48, 0)", +"hsl(120, 25%, 25%, 0.0)", "rgba(48, 80, 48, 0)", +"hsl(150, 25%, 25%, 0.0)", "rgba(48, 80, 64, 0)", +"hsl(180, 25%, 25%, 0.0)", "rgba(48, 80, 80, 0)", +"hsl(210, 25%, 25%, 0.0)", "rgba(48, 64, 80, 0)", +"hsl(240, 25%, 25%, 0.0)", "rgba(48, 48, 80, 0)", +"hsl(270, 25%, 25%, 0.0)", "rgba(64, 48, 80, 0)", +"hsl(300, 25%, 25%, 0.0)", "rgba(80, 48, 80, 0)", +"hsl(330, 25%, 25%, 0.0)", "rgba(80, 48, 64, 0)", +"hsl(0, 37.5%, 25%, 0.0)", "rgba(88, 40, 40, 0)", +"hsl(30, 37.5%, 25%, 0.0)", "rgba(88, 64, 40, 0)", +"hsl(60, 37.5%, 25%, 0.0)", "rgba(88, 88, 40, 0)", +"hsl(90, 37.5%, 25%, 0.0)", "rgba(64, 88, 40, 0)", +"hsl(120, 37.5%, 25%, 0.0)", "rgba(40, 88, 40, 0)", +"hsl(150, 37.5%, 25%, 0.0)", "rgba(40, 88, 64, 0)", +"hsl(180, 37.5%, 25%, 0.0)", "rgba(40, 88, 88, 0)", +"hsl(210, 37.5%, 25%, 0.0)", "rgba(40, 64, 88, 0)", +"hsl(240, 37.5%, 25%, 0.0)", "rgba(40, 40, 88, 0)", +"hsl(270, 37.5%, 25%, 0.0)", "rgba(64, 40, 88, 0)", +"hsl(300, 37.5%, 25%, 0.0)", "rgba(88, 40, 88, 0)", +"hsl(330, 37.5%, 25%, 0.0)", "rgba(88, 40, 64, 0)", +"hsl(0, 50%, 25%, 0.0)", "rgba(96, 32, 32, 0)", +"hsl(30, 50%, 25%, 0.0)", "rgba(96, 64, 32, 0)", +"hsl(60, 50%, 25%, 0.0)", "rgba(96, 96, 32, 0)", +"hsl(90, 50%, 25%, 0.0)", "rgba(64, 96, 32, 0)", +"hsl(120, 50%, 25%, 0.0)", "rgba(32, 96, 32, 0)", +"hsl(150, 50%, 25%, 0.0)", "rgba(32, 96, 64, 0)", +"hsl(180, 50%, 25%, 0.0)", "rgba(32, 96, 96, 0)", +"hsl(210, 50%, 25%, 0.0)", "rgba(32, 64, 96, 0)", +"hsl(240, 50%, 25%, 0.0)", "rgba(32, 32, 96, 0)", +"hsl(270, 50%, 25%, 0.0)", "rgba(64, 32, 96, 0)", +"hsl(300, 50%, 25%, 0.0)", "rgba(96, 32, 96, 0)", +"hsl(330, 50%, 25%, 0.0)", "rgba(96, 32, 64, 0)", +"hsl(0, 62.5%, 25%, 0.0)", "rgba(104, 24, 24, 0)", +"hsl(30, 62.5%, 25%, 0.0)", "rgba(104, 64, 24, 0)", +"hsl(60, 62.5%, 25%, 0.0)", "rgba(104, 104, 24, 0)", +"hsl(90, 62.5%, 25%, 0.0)", "rgba(64, 104, 24, 0)", +"hsl(120, 62.5%, 25%, 0.0)", "rgba(24, 104, 24, 0)", +"hsl(150, 62.5%, 25%, 0.0)", "rgba(24, 104, 64, 0)", +"hsl(180, 62.5%, 25%, 0.0)", "rgba(24, 104, 104, 0)", +"hsl(210, 62.5%, 25%, 0.0)", "rgba(24, 64, 104, 0)", +"hsl(240, 62.5%, 25%, 0.0)", "rgba(24, 24, 104, 0)", +"hsl(270, 62.5%, 25%, 0.0)", "rgba(64, 24, 104, 0)", +"hsl(300, 62.5%, 25%, 0.0)", "rgba(104, 24, 104, 0)", +"hsl(330, 62.5%, 25%, 0.0)", "rgba(104, 24, 64, 0)", +"hsl(0, 75%, 25%, 0.0)", "rgba(112, 16, 16, 0)", +"hsl(30, 75%, 25%, 0.0)", "rgba(112, 64, 16, 0)", +"hsl(60, 75%, 25%, 0.0)", "rgba(112, 112, 16, 0)", +"hsl(90, 75%, 25%, 0.0)", "rgba(64, 112, 16, 0)", +"hsl(120, 75%, 25%, 0.0)", "rgba(16, 112, 16, 0)", +"hsl(150, 75%, 25%, 0.0)", "rgba(16, 112, 64, 0)", +"hsl(180, 75%, 25%, 0.0)", "rgba(16, 112, 112, 0)", +"hsl(210, 75%, 25%, 0.0)", "rgba(16, 64, 112, 0)", +"hsl(240, 75%, 25%, 0.0)", "rgba(16, 16, 112, 0)", +"hsl(270, 75%, 25%, 0.0)", "rgba(64, 16, 112, 0)", +"hsl(300, 75%, 25%, 0.0)", "rgba(112, 16, 112, 0)", +"hsl(330, 75%, 25%, 0.0)", "rgba(112, 16, 64, 0)", +"hsl(0, 87.5%, 25%, 0.0)", "rgba(120, 8, 8, 0)", +"hsl(30, 87.5%, 25%, 0.0)", "rgba(120, 64, 8, 0)", +"hsl(60, 87.5%, 25%, 0.0)", "rgba(120, 120, 8, 0)", +"hsl(90, 87.5%, 25%, 0.0)", "rgba(64, 120, 8, 0)", +"hsl(120, 87.5%, 25%, 0.0)", "rgba(8, 120, 8, 0)", +"hsl(150, 87.5%, 25%, 0.0)", "rgba(8, 120, 64, 0)", +"hsl(180, 87.5%, 25%, 0.0)", "rgba(8, 120, 120, 0)", +"hsl(210, 87.5%, 25%, 0.0)", "rgba(8, 64, 120, 0)", +"hsl(240, 87.5%, 25%, 0.0)", "rgba(8, 8, 120, 0)", +"hsl(270, 87.5%, 25%, 0.0)", "rgba(64, 8, 120, 0)", +"hsl(300, 87.5%, 25%, 0.0)", "rgba(120, 8, 120, 0)", +"hsl(330, 87.5%, 25%, 0.0)", "rgba(120, 8, 64, 0)", +"hsl(0, 100%, 25%, 0.0)", "rgba(128, 0, 0, 0)", +"hsl(30, 100%, 25%, 0.0)", "rgba(128, 64, 0, 0)", +"hsl(60, 100%, 25%, 0.0)", "rgba(128, 128, 0, 0)", +"hsl(90, 100%, 25%, 0.0)", "rgba(64, 128, 0, 0)", +"hsl(120, 100%, 25%, 0.0)", "rgba(0, 128, 0, 0)", +"hsl(150, 100%, 25%, 0.0)", "rgba(0, 128, 64, 0)", +"hsl(180, 100%, 25%, 0.0)", "rgba(0, 128, 128, 0)", +"hsl(210, 100%, 25%, 0.0)", "rgba(0, 64, 128, 0)", +"hsl(240, 100%, 25%, 0.0)", "rgba(0, 0, 128, 0)", +"hsl(270, 100%, 25%, 0.0)", "rgba(64, 0, 128, 0)", +"hsl(300, 100%, 25%, 0.0)", "rgba(128, 0, 128, 0)", +"hsl(330, 100%, 25%, 0.0)", "rgba(128, 0, 64, 0)", +"hsl(0, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(30, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(60, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(90, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(120, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(150, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(180, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(210, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(240, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(270, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(300, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(330, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsl(0, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 84, 0)", +"hsl(30, 12.5%, 37.5%, 0.0)", "rgba(108, 96, 84, 0)", +"hsl(60, 12.5%, 37.5%, 0.0)", "rgba(108, 108, 84, 0)", +"hsl(90, 12.5%, 37.5%, 0.0)", "rgba(96, 108, 84, 0)", +"hsl(120, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 84, 0)", +"hsl(150, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 96, 0)", +"hsl(180, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 108, 0)", +"hsl(210, 12.5%, 37.5%, 0.0)", "rgba(84, 96, 108, 0)", +"hsl(240, 12.5%, 37.5%, 0.0)", "rgba(84, 84, 108, 0)", +"hsl(270, 12.5%, 37.5%, 0.0)", "rgba(96, 84, 108, 0)", +"hsl(300, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 108, 0)", +"hsl(330, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 96, 0)", +"hsl(0, 25%, 37.5%, 0.0)", "rgba(120, 72, 72, 0)", +"hsl(30, 25%, 37.5%, 0.0)", "rgba(120, 96, 72, 0)", +"hsl(60, 25%, 37.5%, 0.0)", "rgba(120, 120, 72, 0)", +"hsl(90, 25%, 37.5%, 0.0)", "rgba(96, 120, 72, 0)", +"hsl(120, 25%, 37.5%, 0.0)", "rgba(72, 120, 72, 0)", +"hsl(150, 25%, 37.5%, 0.0)", "rgba(72, 120, 96, 0)", +"hsl(180, 25%, 37.5%, 0.0)", "rgba(72, 120, 120, 0)", +"hsl(210, 25%, 37.5%, 0.0)", "rgba(72, 96, 120, 0)", +"hsl(240, 25%, 37.5%, 0.0)", "rgba(72, 72, 120, 0)", +"hsl(270, 25%, 37.5%, 0.0)", "rgba(96, 72, 120, 0)", +"hsl(300, 25%, 37.5%, 0.0)", "rgba(120, 72, 120, 0)", +"hsl(330, 25%, 37.5%, 0.0)", "rgba(120, 72, 96, 0)", +"hsl(0, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 60, 0)", +"hsl(30, 37.5%, 37.5%, 0.0)", "rgba(131, 96, 60, 0)", +"hsl(60, 37.5%, 37.5%, 0.0)", "rgba(131, 131, 60, 0)", +"hsl(90, 37.5%, 37.5%, 0.0)", "rgba(96, 131, 60, 0)", +"hsl(120, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 60, 0)", +"hsl(150, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 96, 0)", +"hsl(180, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 131, 0)", +"hsl(210, 37.5%, 37.5%, 0.0)", "rgba(60, 96, 131, 0)", +"hsl(240, 37.5%, 37.5%, 0.0)", "rgba(60, 60, 131, 0)", +"hsl(270, 37.5%, 37.5%, 0.0)", "rgba(96, 60, 131, 0)", +"hsl(300, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 131, 0)", +"hsl(330, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 96, 0)", +"hsl(0, 50%, 37.5%, 0.0)", "rgba(143, 48, 48, 0)", +"hsl(30, 50%, 37.5%, 0.0)", "rgba(143, 96, 48, 0)", +"hsl(60, 50%, 37.5%, 0.0)", "rgba(143, 143, 48, 0)", +"hsl(90, 50%, 37.5%, 0.0)", "rgba(96, 143, 48, 0)", +"hsl(120, 50%, 37.5%, 0.0)", "rgba(48, 143, 48, 0)", +"hsl(150, 50%, 37.5%, 0.0)", "rgba(48, 143, 96, 0)", +"hsl(180, 50%, 37.5%, 0.0)", "rgba(48, 143, 143, 0)", +"hsl(210, 50%, 37.5%, 0.0)", "rgba(48, 96, 143, 0)", +"hsl(240, 50%, 37.5%, 0.0)", "rgba(48, 48, 143, 0)", +"hsl(270, 50%, 37.5%, 0.0)", "rgba(96, 48, 143, 0)", +"hsl(300, 50%, 37.5%, 0.0)", "rgba(143, 48, 143, 0)", +"hsl(330, 50%, 37.5%, 0.0)", "rgba(143, 48, 96, 0)", +"hsl(0, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 36, 0)", +"hsl(30, 62.5%, 37.5%, 0.0)", "rgba(155, 96, 36, 0)", +"hsl(60, 62.5%, 37.5%, 0.0)", "rgba(155, 155, 36, 0)", +"hsl(90, 62.5%, 37.5%, 0.0)", "rgba(96, 155, 36, 0)", +"hsl(120, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 36, 0)", +"hsl(150, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 96, 0)", +"hsl(180, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 155, 0)", +"hsl(210, 62.5%, 37.5%, 0.0)", "rgba(36, 96, 155, 0)", +"hsl(240, 62.5%, 37.5%, 0.0)", "rgba(36, 36, 155, 0)", +"hsl(270, 62.5%, 37.5%, 0.0)", "rgba(96, 36, 155, 0)", +"hsl(300, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 155, 0)", +"hsl(330, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 96, 0)", +"hsl(0, 75%, 37.5%, 0.0)", "rgba(167, 24, 24, 0)", +"hsl(30, 75%, 37.5%, 0.0)", "rgba(167, 96, 24, 0)", +"hsl(60, 75%, 37.5%, 0.0)", "rgba(167, 167, 24, 0)", +"hsl(90, 75%, 37.5%, 0.0)", "rgba(96, 167, 24, 0)", +"hsl(120, 75%, 37.5%, 0.0)", "rgba(24, 167, 24, 0)", +"hsl(150, 75%, 37.5%, 0.0)", "rgba(24, 167, 96, 0)", +"hsl(180, 75%, 37.5%, 0.0)", "rgba(24, 167, 167, 0)", +"hsl(210, 75%, 37.5%, 0.0)", "rgba(24, 96, 167, 0)", +"hsl(240, 75%, 37.5%, 0.0)", "rgba(24, 24, 167, 0)", +"hsl(270, 75%, 37.5%, 0.0)", "rgba(96, 24, 167, 0)", +"hsl(300, 75%, 37.5%, 0.0)", "rgba(167, 24, 167, 0)", +"hsl(330, 75%, 37.5%, 0.0)", "rgba(167, 24, 96, 0)", +"hsl(0, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 12, 0)", +"hsl(30, 87.5%, 37.5%, 0.0)", "rgba(179, 96, 12, 0)", +"hsl(60, 87.5%, 37.5%, 0.0)", "rgba(179, 179, 12, 0)", +"hsl(90, 87.5%, 37.5%, 0.0)", "rgba(96, 179, 12, 0)", +"hsl(120, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 12, 0)", +"hsl(150, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 96, 0)", +"hsl(180, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 179, 0)", +"hsl(210, 87.5%, 37.5%, 0.0)", "rgba(12, 96, 179, 0)", +"hsl(240, 87.5%, 37.5%, 0.0)", "rgba(12, 12, 179, 0)", +"hsl(270, 87.5%, 37.5%, 0.0)", "rgba(96, 12, 179, 0)", +"hsl(300, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 179, 0)", +"hsl(330, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 96, 0)", +"hsl(0, 100%, 37.5%, 0.0)", "rgba(191, 0, 0, 0)", +"hsl(30, 100%, 37.5%, 0.0)", "rgba(191, 96, 0, 0)", +"hsl(60, 100%, 37.5%, 0.0)", "rgba(191, 191, 0, 0)", +"hsl(90, 100%, 37.5%, 0.0)", "rgba(96, 191, 0, 0)", +"hsl(120, 100%, 37.5%, 0.0)", "rgba(0, 191, 0, 0)", +"hsl(150, 100%, 37.5%, 0.0)", "rgba(0, 191, 96, 0)", +"hsl(180, 100%, 37.5%, 0.0)", "rgba(0, 191, 191, 0)", +"hsl(210, 100%, 37.5%, 0.0)", "rgba(0, 96, 191, 0)", +"hsl(240, 100%, 37.5%, 0.0)", "rgba(0, 0, 191, 0)", +"hsl(270, 100%, 37.5%, 0.0)", "rgba(96, 0, 191, 0)", +"hsl(300, 100%, 37.5%, 0.0)", "rgba(191, 0, 191, 0)", +"hsl(330, 100%, 37.5%, 0.0)", "rgba(191, 0, 96, 0)", +"hsl(0, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(30, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(60, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(90, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(120, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(150, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(180, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(210, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(240, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(270, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(300, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(330, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsl(0, 12.5%, 50%, 0.0)", "rgba(143, 112, 112, 0)", +"hsl(30, 12.5%, 50%, 0.0)", "rgba(143, 128, 112, 0)", +"hsl(60, 12.5%, 50%, 0.0)", "rgba(143, 143, 112, 0)", +"hsl(90, 12.5%, 50%, 0.0)", "rgba(128, 143, 112, 0)", +"hsl(120, 12.5%, 50%, 0.0)", "rgba(112, 143, 112, 0)", +"hsl(150, 12.5%, 50%, 0.0)", "rgba(112, 143, 128, 0)", +"hsl(180, 12.5%, 50%, 0.0)", "rgba(112, 143, 143, 0)", +"hsl(210, 12.5%, 50%, 0.0)", "rgba(112, 128, 143, 0)", +"hsl(240, 12.5%, 50%, 0.0)", "rgba(112, 112, 143, 0)", +"hsl(270, 12.5%, 50%, 0.0)", "rgba(128, 112, 143, 0)", +"hsl(300, 12.5%, 50%, 0.0)", "rgba(143, 112, 143, 0)", +"hsl(330, 12.5%, 50%, 0.0)", "rgba(143, 112, 128, 0)", +"hsl(0, 25%, 50%, 0.0)", "rgba(159, 96, 96, 0)", +"hsl(30, 25%, 50%, 0.0)", "rgba(159, 128, 96, 0)", +"hsl(60, 25%, 50%, 0.0)", "rgba(159, 159, 96, 0)", +"hsl(90, 25%, 50%, 0.0)", "rgba(128, 159, 96, 0)", +"hsl(120, 25%, 50%, 0.0)", "rgba(96, 159, 96, 0)", +"hsl(150, 25%, 50%, 0.0)", "rgba(96, 159, 128, 0)", +"hsl(180, 25%, 50%, 0.0)", "rgba(96, 159, 159, 0)", +"hsl(210, 25%, 50%, 0.0)", "rgba(96, 128, 159, 0)", +"hsl(240, 25%, 50%, 0.0)", "rgba(96, 96, 159, 0)", +"hsl(270, 25%, 50%, 0.0)", "rgba(128, 96, 159, 0)", +"hsl(300, 25%, 50%, 0.0)", "rgba(159, 96, 159, 0)", +"hsl(330, 25%, 50%, 0.0)", "rgba(159, 96, 128, 0)", +"hsl(0, 37.5%, 50%, 0.0)", "rgba(175, 80, 80, 0)", +"hsl(30, 37.5%, 50%, 0.0)", "rgba(175, 128, 80, 0)", +"hsl(60, 37.5%, 50%, 0.0)", "rgba(175, 175, 80, 0)", +"hsl(90, 37.5%, 50%, 0.0)", "rgba(128, 175, 80, 0)", +"hsl(120, 37.5%, 50%, 0.0)", "rgba(80, 175, 80, 0)", +"hsl(150, 37.5%, 50%, 0.0)", "rgba(80, 175, 128, 0)", +"hsl(180, 37.5%, 50%, 0.0)", "rgba(80, 175, 175, 0)", +"hsl(210, 37.5%, 50%, 0.0)", "rgba(80, 128, 175, 0)", +"hsl(240, 37.5%, 50%, 0.0)", "rgba(80, 80, 175, 0)", +"hsl(270, 37.5%, 50%, 0.0)", "rgba(128, 80, 175, 0)", +"hsl(300, 37.5%, 50%, 0.0)", "rgba(175, 80, 175, 0)", +"hsl(330, 37.5%, 50%, 0.0)", "rgba(175, 80, 128, 0)", +"hsl(0, 50%, 50%, 0.0)", "rgba(191, 64, 64, 0)", +"hsl(30, 50%, 50%, 0.0)", "rgba(191, 128, 64, 0)", +"hsl(60, 50%, 50%, 0.0)", "rgba(191, 191, 64, 0)", +"hsl(90, 50%, 50%, 0.0)", "rgba(128, 191, 64, 0)", +"hsl(120, 50%, 50%, 0.0)", "rgba(64, 191, 64, 0)", +"hsl(150, 50%, 50%, 0.0)", "rgba(64, 191, 128, 0)", +"hsl(180, 50%, 50%, 0.0)", "rgba(64, 191, 191, 0)", +"hsl(210, 50%, 50%, 0.0)", "rgba(64, 128, 191, 0)", +"hsl(240, 50%, 50%, 0.0)", "rgba(64, 64, 191, 0)", +"hsl(270, 50%, 50%, 0.0)", "rgba(128, 64, 191, 0)", +"hsl(300, 50%, 50%, 0.0)", "rgba(191, 64, 191, 0)", +"hsl(330, 50%, 50%, 0.0)", "rgba(191, 64, 128, 0)", +"hsl(0, 62.5%, 50%, 0.0)", "rgba(207, 48, 48, 0)", +"hsl(30, 62.5%, 50%, 0.0)", "rgba(207, 128, 48, 0)", +"hsl(60, 62.5%, 50%, 0.0)", "rgba(207, 207, 48, 0)", +"hsl(90, 62.5%, 50%, 0.0)", "rgba(128, 207, 48, 0)", +"hsl(120, 62.5%, 50%, 0.0)", "rgba(48, 207, 48, 0)", +"hsl(150, 62.5%, 50%, 0.0)", "rgba(48, 207, 128, 0)", +"hsl(180, 62.5%, 50%, 0.0)", "rgba(48, 207, 207, 0)", +"hsl(210, 62.5%, 50%, 0.0)", "rgba(48, 128, 207, 0)", +"hsl(240, 62.5%, 50%, 0.0)", "rgba(48, 48, 207, 0)", +"hsl(270, 62.5%, 50%, 0.0)", "rgba(128, 48, 207, 0)", +"hsl(300, 62.5%, 50%, 0.0)", "rgba(207, 48, 207, 0)", +"hsl(330, 62.5%, 50%, 0.0)", "rgba(207, 48, 128, 0)", +"hsl(0, 75%, 50%, 0.0)", "rgba(223, 32, 32, 0)", +"hsl(30, 75%, 50%, 0.0)", "rgba(223, 128, 32, 0)", +"hsl(60, 75%, 50%, 0.0)", "rgba(223, 223, 32, 0)", +"hsl(90, 75%, 50%, 0.0)", "rgba(128, 223, 32, 0)", +"hsl(120, 75%, 50%, 0.0)", "rgba(32, 223, 32, 0)", +"hsl(150, 75%, 50%, 0.0)", "rgba(32, 223, 128, 0)", +"hsl(180, 75%, 50%, 0.0)", "rgba(32, 223, 223, 0)", +"hsl(210, 75%, 50%, 0.0)", "rgba(32, 128, 223, 0)", +"hsl(240, 75%, 50%, 0.0)", "rgba(32, 32, 223, 0)", +"hsl(270, 75%, 50%, 0.0)", "rgba(128, 32, 223, 0)", +"hsl(300, 75%, 50%, 0.0)", "rgba(223, 32, 223, 0)", +"hsl(330, 75%, 50%, 0.0)", "rgba(223, 32, 128, 0)", +"hsl(0, 87.5%, 50%, 0.0)", "rgba(239, 16, 16, 0)", +"hsl(30, 87.5%, 50%, 0.0)", "rgba(239, 128, 16, 0)", +"hsl(60, 87.5%, 50%, 0.0)", "rgba(239, 239, 16, 0)", +"hsl(90, 87.5%, 50%, 0.0)", "rgba(128, 239, 16, 0)", +"hsl(120, 87.5%, 50%, 0.0)", "rgba(16, 239, 16, 0)", +"hsl(150, 87.5%, 50%, 0.0)", "rgba(16, 239, 128, 0)", +"hsl(180, 87.5%, 50%, 0.0)", "rgba(16, 239, 239, 0)", +"hsl(210, 87.5%, 50%, 0.0)", "rgba(16, 128, 239, 0)", +"hsl(240, 87.5%, 50%, 0.0)", "rgba(16, 16, 239, 0)", +"hsl(270, 87.5%, 50%, 0.0)", "rgba(128, 16, 239, 0)", +"hsl(300, 87.5%, 50%, 0.0)", "rgba(239, 16, 239, 0)", +"hsl(330, 87.5%, 50%, 0.0)", "rgba(239, 16, 128, 0)", +"hsl(0, 100%, 50%, 0.0)", "rgba(255, 0, 0, 0)", +"hsl(30, 100%, 50%, 0.0)", "rgba(255, 128, 0, 0)", +"hsl(60, 100%, 50%, 0.0)", "rgba(255, 255, 0, 0)", +"hsl(90, 100%, 50%, 0.0)", "rgba(128, 255, 0, 0)", +"hsl(120, 100%, 50%, 0.0)", "rgba(0, 255, 0, 0)", +"hsl(150, 100%, 50%, 0.0)", "rgba(0, 255, 128, 0)", +"hsl(180, 100%, 50%, 0.0)", "rgba(0, 255, 255, 0)", +"hsl(210, 100%, 50%, 0.0)", "rgba(0, 128, 255, 0)", +"hsl(240, 100%, 50%, 0.0)", "rgba(0, 0, 255, 0)", +"hsl(270, 100%, 50%, 0.0)", "rgba(128, 0, 255, 0)", +"hsl(300, 100%, 50%, 0.0)", "rgba(255, 0, 255, 0)", +"hsl(330, 100%, 50%, 0.0)", "rgba(255, 0, 128, 0)", +"hsl(0, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(30, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(60, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(90, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(120, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(150, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(180, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(210, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(240, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(270, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(300, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(330, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsl(0, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 147, 0)", +"hsl(30, 12.5%, 62.5%, 0.0)", "rgba(171, 159, 147, 0)", +"hsl(60, 12.5%, 62.5%, 0.0)", "rgba(171, 171, 147, 0)", +"hsl(90, 12.5%, 62.5%, 0.0)", "rgba(159, 171, 147, 0)", +"hsl(120, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 147, 0)", +"hsl(150, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 159, 0)", +"hsl(180, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 171, 0)", +"hsl(210, 12.5%, 62.5%, 0.0)", "rgba(147, 159, 171, 0)", +"hsl(240, 12.5%, 62.5%, 0.0)", "rgba(147, 147, 171, 0)", +"hsl(270, 12.5%, 62.5%, 0.0)", "rgba(159, 147, 171, 0)", +"hsl(300, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 171, 0)", +"hsl(330, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 159, 0)", +"hsl(0, 25%, 62.5%, 0.0)", "rgba(183, 135, 135, 0)", +"hsl(30, 25%, 62.5%, 0.0)", "rgba(183, 159, 135, 0)", +"hsl(60, 25%, 62.5%, 0.0)", "rgba(183, 183, 135, 0)", +"hsl(90, 25%, 62.5%, 0.0)", "rgba(159, 183, 135, 0)", +"hsl(120, 25%, 62.5%, 0.0)", "rgba(135, 183, 135, 0)", +"hsl(150, 25%, 62.5%, 0.0)", "rgba(135, 183, 159, 0)", +"hsl(180, 25%, 62.5%, 0.0)", "rgba(135, 183, 183, 0)", +"hsl(210, 25%, 62.5%, 0.0)", "rgba(135, 159, 183, 0)", +"hsl(240, 25%, 62.5%, 0.0)", "rgba(135, 135, 183, 0)", +"hsl(270, 25%, 62.5%, 0.0)", "rgba(159, 135, 183, 0)", +"hsl(300, 25%, 62.5%, 0.0)", "rgba(183, 135, 183, 0)", +"hsl(330, 25%, 62.5%, 0.0)", "rgba(183, 135, 159, 0)", +"hsl(0, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 124, 0)", +"hsl(30, 37.5%, 62.5%, 0.0)", "rgba(195, 159, 124, 0)", +"hsl(60, 37.5%, 62.5%, 0.0)", "rgba(195, 195, 124, 0)", +"hsl(90, 37.5%, 62.5%, 0.0)", "rgba(159, 195, 124, 0)", +"hsl(120, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 124, 0)", +"hsl(150, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 159, 0)", +"hsl(180, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 195, 0)", +"hsl(210, 37.5%, 62.5%, 0.0)", "rgba(124, 159, 195, 0)", +"hsl(240, 37.5%, 62.5%, 0.0)", "rgba(124, 124, 195, 0)", +"hsl(270, 37.5%, 62.5%, 0.0)", "rgba(159, 124, 195, 0)", +"hsl(300, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 195, 0)", +"hsl(330, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 159, 0)", +"hsl(0, 50%, 62.5%, 0.0)", "rgba(207, 112, 112, 0)", +"hsl(30, 50%, 62.5%, 0.0)", "rgba(207, 159, 112, 0)", +"hsl(60, 50%, 62.5%, 0.0)", "rgba(207, 207, 112, 0)", +"hsl(90, 50%, 62.5%, 0.0)", "rgba(159, 207, 112, 0)", +"hsl(120, 50%, 62.5%, 0.0)", "rgba(112, 207, 112, 0)", +"hsl(150, 50%, 62.5%, 0.0)", "rgba(112, 207, 159, 0)", +"hsl(180, 50%, 62.5%, 0.0)", "rgba(112, 207, 207, 0)", +"hsl(210, 50%, 62.5%, 0.0)", "rgba(112, 159, 207, 0)", +"hsl(240, 50%, 62.5%, 0.0)", "rgba(112, 112, 207, 0)", +"hsl(270, 50%, 62.5%, 0.0)", "rgba(159, 112, 207, 0)", +"hsl(300, 50%, 62.5%, 0.0)", "rgba(207, 112, 207, 0)", +"hsl(330, 50%, 62.5%, 0.0)", "rgba(207, 112, 159, 0)", +"hsl(0, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 100, 0)", +"hsl(30, 62.5%, 62.5%, 0.0)", "rgba(219, 159, 100, 0)", +"hsl(60, 62.5%, 62.5%, 0.0)", "rgba(219, 219, 100, 0)", +"hsl(90, 62.5%, 62.5%, 0.0)", "rgba(159, 219, 100, 0)", +"hsl(120, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 100, 0)", +"hsl(150, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 159, 0)", +"hsl(180, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 219, 0)", +"hsl(210, 62.5%, 62.5%, 0.0)", "rgba(100, 159, 219, 0)", +"hsl(240, 62.5%, 62.5%, 0.0)", "rgba(100, 100, 219, 0)", +"hsl(270, 62.5%, 62.5%, 0.0)", "rgba(159, 100, 219, 0)", +"hsl(300, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 219, 0)", +"hsl(330, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 159, 0)", +"hsl(0, 75%, 62.5%, 0.0)", "rgba(231, 88, 88, 0)", +"hsl(30, 75%, 62.5%, 0.0)", "rgba(231, 159, 88, 0)", +"hsl(60, 75%, 62.5%, 0.0)", "rgba(231, 231, 88, 0)", +"hsl(90, 75%, 62.5%, 0.0)", "rgba(159, 231, 88, 0)", +"hsl(120, 75%, 62.5%, 0.0)", "rgba(88, 231, 88, 0)", +"hsl(150, 75%, 62.5%, 0.0)", "rgba(88, 231, 159, 0)", +"hsl(180, 75%, 62.5%, 0.0)", "rgba(88, 231, 231, 0)", +"hsl(210, 75%, 62.5%, 0.0)", "rgba(88, 159, 231, 0)", +"hsl(240, 75%, 62.5%, 0.0)", "rgba(88, 88, 231, 0)", +"hsl(270, 75%, 62.5%, 0.0)", "rgba(159, 88, 231, 0)", +"hsl(300, 75%, 62.5%, 0.0)", "rgba(231, 88, 231, 0)", +"hsl(330, 75%, 62.5%, 0.0)", "rgba(231, 88, 159, 0)", +"hsl(0, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 76, 0)", +"hsl(30, 87.5%, 62.5%, 0.0)", "rgba(243, 159, 76, 0)", +"hsl(60, 87.5%, 62.5%, 0.0)", "rgba(243, 243, 76, 0)", +"hsl(90, 87.5%, 62.5%, 0.0)", "rgba(159, 243, 76, 0)", +"hsl(120, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 76, 0)", +"hsl(150, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 159, 0)", +"hsl(180, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 243, 0)", +"hsl(210, 87.5%, 62.5%, 0.0)", "rgba(76, 159, 243, 0)", +"hsl(240, 87.5%, 62.5%, 0.0)", "rgba(76, 76, 243, 0)", +"hsl(270, 87.5%, 62.5%, 0.0)", "rgba(159, 76, 243, 0)", +"hsl(300, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 243, 0)", +"hsl(330, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 159, 0)", +"hsl(0, 100%, 62.5%, 0.0)", "rgba(255, 64, 64, 0)", +"hsl(30, 100%, 62.5%, 0.0)", "rgba(255, 159, 64, 0)", +"hsl(60, 100%, 62.5%, 0.0)", "rgba(255, 255, 64, 0)", +"hsl(90, 100%, 62.5%, 0.0)", "rgba(159, 255, 64, 0)", +"hsl(120, 100%, 62.5%, 0.0)", "rgba(64, 255, 64, 0)", +"hsl(150, 100%, 62.5%, 0.0)", "rgba(64, 255, 159, 0)", +"hsl(180, 100%, 62.5%, 0.0)", "rgba(64, 255, 255, 0)", +"hsl(210, 100%, 62.5%, 0.0)", "rgba(64, 159, 255, 0)", +"hsl(240, 100%, 62.5%, 0.0)", "rgba(64, 64, 255, 0)", +"hsl(270, 100%, 62.5%, 0.0)", "rgba(159, 64, 255, 0)", +"hsl(300, 100%, 62.5%, 0.0)", "rgba(255, 64, 255, 0)", +"hsl(330, 100%, 62.5%, 0.0)", "rgba(255, 64, 159, 0)", +"hsl(0, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(30, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(60, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(90, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(120, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(150, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(180, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(210, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(240, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(270, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(300, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(330, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsl(0, 12.5%, 75%, 0.0)", "rgba(199, 183, 183, 0)", +"hsl(30, 12.5%, 75%, 0.0)", "rgba(199, 191, 183, 0)", +"hsl(60, 12.5%, 75%, 0.0)", "rgba(199, 199, 183, 0)", +"hsl(90, 12.5%, 75%, 0.0)", "rgba(191, 199, 183, 0)", +"hsl(120, 12.5%, 75%, 0.0)", "rgba(183, 199, 183, 0)", +"hsl(150, 12.5%, 75%, 0.0)", "rgba(183, 199, 191, 0)", +"hsl(180, 12.5%, 75%, 0.0)", "rgba(183, 199, 199, 0)", +"hsl(210, 12.5%, 75%, 0.0)", "rgba(183, 191, 199, 0)", +"hsl(240, 12.5%, 75%, 0.0)", "rgba(183, 183, 199, 0)", +"hsl(270, 12.5%, 75%, 0.0)", "rgba(191, 183, 199, 0)", +"hsl(300, 12.5%, 75%, 0.0)", "rgba(199, 183, 199, 0)", +"hsl(330, 12.5%, 75%, 0.0)", "rgba(199, 183, 191, 0)", +"hsl(0, 25%, 75%, 0.0)", "rgba(207, 175, 175, 0)", +"hsl(30, 25%, 75%, 0.0)", "rgba(207, 191, 175, 0)", +"hsl(60, 25%, 75%, 0.0)", "rgba(207, 207, 175, 0)", +"hsl(90, 25%, 75%, 0.0)", "rgba(191, 207, 175, 0)", +"hsl(120, 25%, 75%, 0.0)", "rgba(175, 207, 175, 0)", +"hsl(150, 25%, 75%, 0.0)", "rgba(175, 207, 191, 0)", +"hsl(180, 25%, 75%, 0.0)", "rgba(175, 207, 207, 0)", +"hsl(210, 25%, 75%, 0.0)", "rgba(175, 191, 207, 0)", +"hsl(240, 25%, 75%, 0.0)", "rgba(175, 175, 207, 0)", +"hsl(270, 25%, 75%, 0.0)", "rgba(191, 175, 207, 0)", +"hsl(300, 25%, 75%, 0.0)", "rgba(207, 175, 207, 0)", +"hsl(330, 25%, 75%, 0.0)", "rgba(207, 175, 191, 0)", +"hsl(0, 37.5%, 75%, 0.0)", "rgba(215, 167, 167, 0)", +"hsl(30, 37.5%, 75%, 0.0)", "rgba(215, 191, 167, 0)", +"hsl(60, 37.5%, 75%, 0.0)", "rgba(215, 215, 167, 0)", +"hsl(90, 37.5%, 75%, 0.0)", "rgba(191, 215, 167, 0)", +"hsl(120, 37.5%, 75%, 0.0)", "rgba(167, 215, 167, 0)", +"hsl(150, 37.5%, 75%, 0.0)", "rgba(167, 215, 191, 0)", +"hsl(180, 37.5%, 75%, 0.0)", "rgba(167, 215, 215, 0)", +"hsl(210, 37.5%, 75%, 0.0)", "rgba(167, 191, 215, 0)", +"hsl(240, 37.5%, 75%, 0.0)", "rgba(167, 167, 215, 0)", +"hsl(270, 37.5%, 75%, 0.0)", "rgba(191, 167, 215, 0)", +"hsl(300, 37.5%, 75%, 0.0)", "rgba(215, 167, 215, 0)", +"hsl(330, 37.5%, 75%, 0.0)", "rgba(215, 167, 191, 0)", +"hsl(0, 50%, 75%, 0.0)", "rgba(223, 159, 159, 0)", +"hsl(30, 50%, 75%, 0.0)", "rgba(223, 191, 159, 0)", +"hsl(60, 50%, 75%, 0.0)", "rgba(223, 223, 159, 0)", +"hsl(90, 50%, 75%, 0.0)", "rgba(191, 223, 159, 0)", +"hsl(120, 50%, 75%, 0.0)", "rgba(159, 223, 159, 0)", +"hsl(150, 50%, 75%, 0.0)", "rgba(159, 223, 191, 0)", +"hsl(180, 50%, 75%, 0.0)", "rgba(159, 223, 223, 0)", +"hsl(210, 50%, 75%, 0.0)", "rgba(159, 191, 223, 0)", +"hsl(240, 50%, 75%, 0.0)", "rgba(159, 159, 223, 0)", +"hsl(270, 50%, 75%, 0.0)", "rgba(191, 159, 223, 0)", +"hsl(300, 50%, 75%, 0.0)", "rgba(223, 159, 223, 0)", +"hsl(330, 50%, 75%, 0.0)", "rgba(223, 159, 191, 0)", +"hsl(0, 62.5%, 75%, 0.0)", "rgba(231, 151, 151, 0)", +"hsl(30, 62.5%, 75%, 0.0)", "rgba(231, 191, 151, 0)", +"hsl(60, 62.5%, 75%, 0.0)", "rgba(231, 231, 151, 0)", +"hsl(90, 62.5%, 75%, 0.0)", "rgba(191, 231, 151, 0)", +"hsl(120, 62.5%, 75%, 0.0)", "rgba(151, 231, 151, 0)", +"hsl(150, 62.5%, 75%, 0.0)", "rgba(151, 231, 191, 0)", +"hsl(180, 62.5%, 75%, 0.0)", "rgba(151, 231, 231, 0)", +"hsl(210, 62.5%, 75%, 0.0)", "rgba(151, 191, 231, 0)", +"hsl(240, 62.5%, 75%, 0.0)", "rgba(151, 151, 231, 0)", +"hsl(270, 62.5%, 75%, 0.0)", "rgba(191, 151, 231, 0)", +"hsl(300, 62.5%, 75%, 0.0)", "rgba(231, 151, 231, 0)", +"hsl(330, 62.5%, 75%, 0.0)", "rgba(231, 151, 191, 0)", +"hsl(0, 75%, 75%, 0.0)", "rgba(239, 143, 143, 0)", +"hsl(30, 75%, 75%, 0.0)", "rgba(239, 191, 143, 0)", +"hsl(60, 75%, 75%, 0.0)", "rgba(239, 239, 143, 0)", +"hsl(90, 75%, 75%, 0.0)", "rgba(191, 239, 143, 0)", +"hsl(120, 75%, 75%, 0.0)", "rgba(143, 239, 143, 0)", +"hsl(150, 75%, 75%, 0.0)", "rgba(143, 239, 191, 0)", +"hsl(180, 75%, 75%, 0.0)", "rgba(143, 239, 239, 0)", +"hsl(210, 75%, 75%, 0.0)", "rgba(143, 191, 239, 0)", +"hsl(240, 75%, 75%, 0.0)", "rgba(143, 143, 239, 0)", +"hsl(270, 75%, 75%, 0.0)", "rgba(191, 143, 239, 0)", +"hsl(300, 75%, 75%, 0.0)", "rgba(239, 143, 239, 0)", +"hsl(330, 75%, 75%, 0.0)", "rgba(239, 143, 191, 0)", +"hsl(0, 87.5%, 75%, 0.0)", "rgba(247, 135, 135, 0)", +"hsl(30, 87.5%, 75%, 0.0)", "rgba(247, 191, 135, 0)", +"hsl(60, 87.5%, 75%, 0.0)", "rgba(247, 247, 135, 0)", +"hsl(90, 87.5%, 75%, 0.0)", "rgba(191, 247, 135, 0)", +"hsl(120, 87.5%, 75%, 0.0)", "rgba(135, 247, 135, 0)", +"hsl(150, 87.5%, 75%, 0.0)", "rgba(135, 247, 191, 0)", +"hsl(180, 87.5%, 75%, 0.0)", "rgba(135, 247, 247, 0)", +"hsl(210, 87.5%, 75%, 0.0)", "rgba(135, 191, 247, 0)", +"hsl(240, 87.5%, 75%, 0.0)", "rgba(135, 135, 247, 0)", +"hsl(270, 87.5%, 75%, 0.0)", "rgba(191, 135, 247, 0)", +"hsl(300, 87.5%, 75%, 0.0)", "rgba(247, 135, 247, 0)", +"hsl(330, 87.5%, 75%, 0.0)", "rgba(247, 135, 191, 0)", +"hsl(0, 100%, 75%, 0.0)", "rgba(255, 128, 128, 0)", +"hsl(30, 100%, 75%, 0.0)", "rgba(255, 191, 128, 0)", +"hsl(60, 100%, 75%, 0.0)", "rgba(255, 255, 128, 0)", +"hsl(90, 100%, 75%, 0.0)", "rgba(191, 255, 128, 0)", +"hsl(120, 100%, 75%, 0.0)", "rgba(128, 255, 128, 0)", +"hsl(150, 100%, 75%, 0.0)", "rgba(128, 255, 191, 0)", +"hsl(180, 100%, 75%, 0.0)", "rgba(128, 255, 255, 0)", +"hsl(210, 100%, 75%, 0.0)", "rgba(128, 191, 255, 0)", +"hsl(240, 100%, 75%, 0.0)", "rgba(128, 128, 255, 0)", +"hsl(270, 100%, 75%, 0.0)", "rgba(191, 128, 255, 0)", +"hsl(300, 100%, 75%, 0.0)", "rgba(255, 128, 255, 0)", +"hsl(330, 100%, 75%, 0.0)", "rgba(255, 128, 191, 0)", +"hsl(0, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(30, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(60, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(90, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(120, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(150, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(180, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(210, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(240, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(270, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(300, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(330, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsl(0, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 219, 0)", +"hsl(30, 12.5%, 87.5%, 0.0)", "rgba(227, 223, 219, 0)", +"hsl(60, 12.5%, 87.5%, 0.0)", "rgba(227, 227, 219, 0)", +"hsl(90, 12.5%, 87.5%, 0.0)", "rgba(223, 227, 219, 0)", +"hsl(120, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 219, 0)", +"hsl(150, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 223, 0)", +"hsl(180, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 227, 0)", +"hsl(210, 12.5%, 87.5%, 0.0)", "rgba(219, 223, 227, 0)", +"hsl(240, 12.5%, 87.5%, 0.0)", "rgba(219, 219, 227, 0)", +"hsl(270, 12.5%, 87.5%, 0.0)", "rgba(223, 219, 227, 0)", +"hsl(300, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 227, 0)", +"hsl(330, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 223, 0)", +"hsl(0, 25%, 87.5%, 0.0)", "rgba(231, 215, 215, 0)", +"hsl(30, 25%, 87.5%, 0.0)", "rgba(231, 223, 215, 0)", +"hsl(60, 25%, 87.5%, 0.0)", "rgba(231, 231, 215, 0)", +"hsl(90, 25%, 87.5%, 0.0)", "rgba(223, 231, 215, 0)", +"hsl(120, 25%, 87.5%, 0.0)", "rgba(215, 231, 215, 0)", +"hsl(150, 25%, 87.5%, 0.0)", "rgba(215, 231, 223, 0)", +"hsl(180, 25%, 87.5%, 0.0)", "rgba(215, 231, 231, 0)", +"hsl(210, 25%, 87.5%, 0.0)", "rgba(215, 223, 231, 0)", +"hsl(240, 25%, 87.5%, 0.0)", "rgba(215, 215, 231, 0)", +"hsl(270, 25%, 87.5%, 0.0)", "rgba(223, 215, 231, 0)", +"hsl(300, 25%, 87.5%, 0.0)", "rgba(231, 215, 231, 0)", +"hsl(330, 25%, 87.5%, 0.0)", "rgba(231, 215, 223, 0)", +"hsl(0, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 211, 0)", +"hsl(30, 37.5%, 87.5%, 0.0)", "rgba(235, 223, 211, 0)", +"hsl(60, 37.5%, 87.5%, 0.0)", "rgba(235, 235, 211, 0)", +"hsl(90, 37.5%, 87.5%, 0.0)", "rgba(223, 235, 211, 0)", +"hsl(120, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 211, 0)", +"hsl(150, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 223, 0)", +"hsl(180, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 235, 0)", +"hsl(210, 37.5%, 87.5%, 0.0)", "rgba(211, 223, 235, 0)", +"hsl(240, 37.5%, 87.5%, 0.0)", "rgba(211, 211, 235, 0)", +"hsl(270, 37.5%, 87.5%, 0.0)", "rgba(223, 211, 235, 0)", +"hsl(300, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 235, 0)", +"hsl(330, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 223, 0)", +"hsl(0, 50%, 87.5%, 0.0)", "rgba(239, 207, 207, 0)", +"hsl(30, 50%, 87.5%, 0.0)", "rgba(239, 223, 207, 0)", +"hsl(60, 50%, 87.5%, 0.0)", "rgba(239, 239, 207, 0)", +"hsl(90, 50%, 87.5%, 0.0)", "rgba(223, 239, 207, 0)", +"hsl(120, 50%, 87.5%, 0.0)", "rgba(207, 239, 207, 0)", +"hsl(150, 50%, 87.5%, 0.0)", "rgba(207, 239, 223, 0)", +"hsl(180, 50%, 87.5%, 0.0)", "rgba(207, 239, 239, 0)", +"hsl(210, 50%, 87.5%, 0.0)", "rgba(207, 223, 239, 0)", +"hsl(240, 50%, 87.5%, 0.0)", "rgba(207, 207, 239, 0)", +"hsl(270, 50%, 87.5%, 0.0)", "rgba(223, 207, 239, 0)", +"hsl(300, 50%, 87.5%, 0.0)", "rgba(239, 207, 239, 0)", +"hsl(330, 50%, 87.5%, 0.0)", "rgba(239, 207, 223, 0)", +"hsl(0, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 203, 0)", +"hsl(30, 62.5%, 87.5%, 0.0)", "rgba(243, 223, 203, 0)", +"hsl(60, 62.5%, 87.5%, 0.0)", "rgba(243, 243, 203, 0)", +"hsl(90, 62.5%, 87.5%, 0.0)", "rgba(223, 243, 203, 0)", +"hsl(120, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 203, 0)", +"hsl(150, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 223, 0)", +"hsl(180, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 243, 0)", +"hsl(210, 62.5%, 87.5%, 0.0)", "rgba(203, 223, 243, 0)", +"hsl(240, 62.5%, 87.5%, 0.0)", "rgba(203, 203, 243, 0)", +"hsl(270, 62.5%, 87.5%, 0.0)", "rgba(223, 203, 243, 0)", +"hsl(300, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 243, 0)", +"hsl(330, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 223, 0)", +"hsl(0, 75%, 87.5%, 0.0)", "rgba(247, 199, 199, 0)", +"hsl(30, 75%, 87.5%, 0.0)", "rgba(247, 223, 199, 0)", +"hsl(60, 75%, 87.5%, 0.0)", "rgba(247, 247, 199, 0)", +"hsl(90, 75%, 87.5%, 0.0)", "rgba(223, 247, 199, 0)", +"hsl(120, 75%, 87.5%, 0.0)", "rgba(199, 247, 199, 0)", +"hsl(150, 75%, 87.5%, 0.0)", "rgba(199, 247, 223, 0)", +"hsl(180, 75%, 87.5%, 0.0)", "rgba(199, 247, 247, 0)", +"hsl(210, 75%, 87.5%, 0.0)", "rgba(199, 223, 247, 0)", +"hsl(240, 75%, 87.5%, 0.0)", "rgba(199, 199, 247, 0)", +"hsl(270, 75%, 87.5%, 0.0)", "rgba(223, 199, 247, 0)", +"hsl(300, 75%, 87.5%, 0.0)", "rgba(247, 199, 247, 0)", +"hsl(330, 75%, 87.5%, 0.0)", "rgba(247, 199, 223, 0)", +"hsl(0, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 195, 0)", +"hsl(30, 87.5%, 87.5%, 0.0)", "rgba(251, 223, 195, 0)", +"hsl(60, 87.5%, 87.5%, 0.0)", "rgba(251, 251, 195, 0)", +"hsl(90, 87.5%, 87.5%, 0.0)", "rgba(223, 251, 195, 0)", +"hsl(120, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 195, 0)", +"hsl(150, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 223, 0)", +"hsl(180, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 251, 0)", +"hsl(210, 87.5%, 87.5%, 0.0)", "rgba(195, 223, 251, 0)", +"hsl(240, 87.5%, 87.5%, 0.0)", "rgba(195, 195, 251, 0)", +"hsl(270, 87.5%, 87.5%, 0.0)", "rgba(223, 195, 251, 0)", +"hsl(300, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 251, 0)", +"hsl(330, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 223, 0)", +"hsl(0, 100%, 87.5%, 0.0)", "rgba(255, 191, 191, 0)", +"hsl(30, 100%, 87.5%, 0.0)", "rgba(255, 223, 191, 0)", +"hsl(60, 100%, 87.5%, 0.0)", "rgba(255, 255, 191, 0)", +"hsl(90, 100%, 87.5%, 0.0)", "rgba(223, 255, 191, 0)", +"hsl(120, 100%, 87.5%, 0.0)", "rgba(191, 255, 191, 0)", +"hsl(150, 100%, 87.5%, 0.0)", "rgba(191, 255, 223, 0)", +"hsl(180, 100%, 87.5%, 0.0)", "rgba(191, 255, 255, 0)", +"hsl(210, 100%, 87.5%, 0.0)", "rgba(191, 223, 255, 0)", +"hsl(240, 100%, 87.5%, 0.0)", "rgba(191, 191, 255, 0)", +"hsl(270, 100%, 87.5%, 0.0)", "rgba(223, 191, 255, 0)", +"hsl(300, 100%, 87.5%, 0.0)", "rgba(255, 191, 255, 0)", +"hsl(330, 100%, 87.5%, 0.0)", "rgba(255, 191, 223, 0)", +"hsl(0, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 0%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 12.5%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 25%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 37.5%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 50%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 62.5%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 75%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 87.5%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(30, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(60, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(90, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(120, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(150, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(180, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(210, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(240, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(270, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(300, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(330, 100%, 0%)", "rgb(0, 0, 0)", +"hsla(0, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(30, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(60, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(90, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(120, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(150, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(180, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(210, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(240, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(270, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(300, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(330, 0%, 12.5%)", "rgb(32, 32, 32)", +"hsla(0, 12.5%, 12.5%)", "rgb(36, 28, 28)", +"hsla(30, 12.5%, 12.5%)", "rgb(36, 32, 28)", +"hsla(60, 12.5%, 12.5%)", "rgb(36, 36, 28)", +"hsla(90, 12.5%, 12.5%)", "rgb(32, 36, 28)", +"hsla(120, 12.5%, 12.5%)", "rgb(28, 36, 28)", +"hsla(150, 12.5%, 12.5%)", "rgb(28, 36, 32)", +"hsla(180, 12.5%, 12.5%)", "rgb(28, 36, 36)", +"hsla(210, 12.5%, 12.5%)", "rgb(28, 32, 36)", +"hsla(240, 12.5%, 12.5%)", "rgb(28, 28, 36)", +"hsla(270, 12.5%, 12.5%)", "rgb(32, 28, 36)", +"hsla(300, 12.5%, 12.5%)", "rgb(36, 28, 36)", +"hsla(330, 12.5%, 12.5%)", "rgb(36, 28, 32)", +"hsla(0, 25%, 12.5%)", "rgb(40, 24, 24)", +"hsla(30, 25%, 12.5%)", "rgb(40, 32, 24)", +"hsla(60, 25%, 12.5%)", "rgb(40, 40, 24)", +"hsla(90, 25%, 12.5%)", "rgb(32, 40, 24)", +"hsla(120, 25%, 12.5%)", "rgb(24, 40, 24)", +"hsla(150, 25%, 12.5%)", "rgb(24, 40, 32)", +"hsla(180, 25%, 12.5%)", "rgb(24, 40, 40)", +"hsla(210, 25%, 12.5%)", "rgb(24, 32, 40)", +"hsla(240, 25%, 12.5%)", "rgb(24, 24, 40)", +"hsla(270, 25%, 12.5%)", "rgb(32, 24, 40)", +"hsla(300, 25%, 12.5%)", "rgb(40, 24, 40)", +"hsla(330, 25%, 12.5%)", "rgb(40, 24, 32)", +"hsla(0, 37.5%, 12.5%)", "rgb(44, 20, 20)", +"hsla(30, 37.5%, 12.5%)", "rgb(44, 32, 20)", +"hsla(60, 37.5%, 12.5%)", "rgb(44, 44, 20)", +"hsla(90, 37.5%, 12.5%)", "rgb(32, 44, 20)", +"hsla(120, 37.5%, 12.5%)", "rgb(20, 44, 20)", +"hsla(150, 37.5%, 12.5%)", "rgb(20, 44, 32)", +"hsla(180, 37.5%, 12.5%)", "rgb(20, 44, 44)", +"hsla(210, 37.5%, 12.5%)", "rgb(20, 32, 44)", +"hsla(240, 37.5%, 12.5%)", "rgb(20, 20, 44)", +"hsla(270, 37.5%, 12.5%)", "rgb(32, 20, 44)", +"hsla(300, 37.5%, 12.5%)", "rgb(44, 20, 44)", +"hsla(330, 37.5%, 12.5%)", "rgb(44, 20, 32)", +"hsla(0, 50%, 12.5%)", "rgb(48, 16, 16)", +"hsla(30, 50%, 12.5%)", "rgb(48, 32, 16)", +"hsla(60, 50%, 12.5%)", "rgb(48, 48, 16)", +"hsla(90, 50%, 12.5%)", "rgb(32, 48, 16)", +"hsla(120, 50%, 12.5%)", "rgb(16, 48, 16)", +"hsla(150, 50%, 12.5%)", "rgb(16, 48, 32)", +"hsla(180, 50%, 12.5%)", "rgb(16, 48, 48)", +"hsla(210, 50%, 12.5%)", "rgb(16, 32, 48)", +"hsla(240, 50%, 12.5%)", "rgb(16, 16, 48)", +"hsla(270, 50%, 12.5%)", "rgb(32, 16, 48)", +"hsla(300, 50%, 12.5%)", "rgb(48, 16, 48)", +"hsla(330, 50%, 12.5%)", "rgb(48, 16, 32)", +"hsla(0, 62.5%, 12.5%)", "rgb(52, 12, 12)", +"hsla(30, 62.5%, 12.5%)", "rgb(52, 32, 12)", +"hsla(60, 62.5%, 12.5%)", "rgb(52, 52, 12)", +"hsla(90, 62.5%, 12.5%)", "rgb(32, 52, 12)", +"hsla(120, 62.5%, 12.5%)", "rgb(12, 52, 12)", +"hsla(150, 62.5%, 12.5%)", "rgb(12, 52, 32)", +"hsla(180, 62.5%, 12.5%)", "rgb(12, 52, 52)", +"hsla(210, 62.5%, 12.5%)", "rgb(12, 32, 52)", +"hsla(240, 62.5%, 12.5%)", "rgb(12, 12, 52)", +"hsla(270, 62.5%, 12.5%)", "rgb(32, 12, 52)", +"hsla(300, 62.5%, 12.5%)", "rgb(52, 12, 52)", +"hsla(330, 62.5%, 12.5%)", "rgb(52, 12, 32)", +"hsla(0, 75%, 12.5%)", "rgb(56, 8, 8)", +"hsla(30, 75%, 12.5%)", "rgb(56, 32, 8)", +"hsla(60, 75%, 12.5%)", "rgb(56, 56, 8)", +"hsla(90, 75%, 12.5%)", "rgb(32, 56, 8)", +"hsla(120, 75%, 12.5%)", "rgb(8, 56, 8)", +"hsla(150, 75%, 12.5%)", "rgb(8, 56, 32)", +"hsla(180, 75%, 12.5%)", "rgb(8, 56, 56)", +"hsla(210, 75%, 12.5%)", "rgb(8, 32, 56)", +"hsla(240, 75%, 12.5%)", "rgb(8, 8, 56)", +"hsla(270, 75%, 12.5%)", "rgb(32, 8, 56)", +"hsla(300, 75%, 12.5%)", "rgb(56, 8, 56)", +"hsla(330, 75%, 12.5%)", "rgb(56, 8, 32)", +"hsla(0, 87.5%, 12.5%)", "rgb(60, 4, 4)", +"hsla(30, 87.5%, 12.5%)", "rgb(60, 32, 4)", +"hsla(60, 87.5%, 12.5%)", "rgb(60, 60, 4)", +"hsla(90, 87.5%, 12.5%)", "rgb(32, 60, 4)", +"hsla(120, 87.5%, 12.5%)", "rgb(4, 60, 4)", +"hsla(150, 87.5%, 12.5%)", "rgb(4, 60, 32)", +"hsla(180, 87.5%, 12.5%)", "rgb(4, 60, 60)", +"hsla(210, 87.5%, 12.5%)", "rgb(4, 32, 60)", +"hsla(240, 87.5%, 12.5%)", "rgb(4, 4, 60)", +"hsla(270, 87.5%, 12.5%)", "rgb(32, 4, 60)", +"hsla(300, 87.5%, 12.5%)", "rgb(60, 4, 60)", +"hsla(330, 87.5%, 12.5%)", "rgb(60, 4, 32)", +"hsla(0, 100%, 12.5%)", "rgb(64, 0, 0)", +"hsla(30, 100%, 12.5%)", "rgb(64, 32, 0)", +"hsla(60, 100%, 12.5%)", "rgb(64, 64, 0)", +"hsla(90, 100%, 12.5%)", "rgb(32, 64, 0)", +"hsla(120, 100%, 12.5%)", "rgb(0, 64, 0)", +"hsla(150, 100%, 12.5%)", "rgb(0, 64, 32)", +"hsla(180, 100%, 12.5%)", "rgb(0, 64, 64)", +"hsla(210, 100%, 12.5%)", "rgb(0, 32, 64)", +"hsla(240, 100%, 12.5%)", "rgb(0, 0, 64)", +"hsla(270, 100%, 12.5%)", "rgb(32, 0, 64)", +"hsla(300, 100%, 12.5%)", "rgb(64, 0, 64)", +"hsla(330, 100%, 12.5%)", "rgb(64, 0, 32)", +"hsla(0, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(30, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(60, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(90, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(120, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(150, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(180, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(210, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(240, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(270, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(300, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(330, 0%, 25%)", "rgb(64, 64, 64)", +"hsla(0, 12.5%, 25%)", "rgb(72, 56, 56)", +"hsla(30, 12.5%, 25%)", "rgb(72, 64, 56)", +"hsla(60, 12.5%, 25%)", "rgb(72, 72, 56)", +"hsla(90, 12.5%, 25%)", "rgb(64, 72, 56)", +"hsla(120, 12.5%, 25%)", "rgb(56, 72, 56)", +"hsla(150, 12.5%, 25%)", "rgb(56, 72, 64)", +"hsla(180, 12.5%, 25%)", "rgb(56, 72, 72)", +"hsla(210, 12.5%, 25%)", "rgb(56, 64, 72)", +"hsla(240, 12.5%, 25%)", "rgb(56, 56, 72)", +"hsla(270, 12.5%, 25%)", "rgb(64, 56, 72)", +"hsla(300, 12.5%, 25%)", "rgb(72, 56, 72)", +"hsla(330, 12.5%, 25%)", "rgb(72, 56, 64)", +"hsla(0, 25%, 25%)", "rgb(80, 48, 48)", +"hsla(30, 25%, 25%)", "rgb(80, 64, 48)", +"hsla(60, 25%, 25%)", "rgb(80, 80, 48)", +"hsla(90, 25%, 25%)", "rgb(64, 80, 48)", +"hsla(120, 25%, 25%)", "rgb(48, 80, 48)", +"hsla(150, 25%, 25%)", "rgb(48, 80, 64)", +"hsla(180, 25%, 25%)", "rgb(48, 80, 80)", +"hsla(210, 25%, 25%)", "rgb(48, 64, 80)", +"hsla(240, 25%, 25%)", "rgb(48, 48, 80)", +"hsla(270, 25%, 25%)", "rgb(64, 48, 80)", +"hsla(300, 25%, 25%)", "rgb(80, 48, 80)", +"hsla(330, 25%, 25%)", "rgb(80, 48, 64)", +"hsla(0, 37.5%, 25%)", "rgb(88, 40, 40)", +"hsla(30, 37.5%, 25%)", "rgb(88, 64, 40)", +"hsla(60, 37.5%, 25%)", "rgb(88, 88, 40)", +"hsla(90, 37.5%, 25%)", "rgb(64, 88, 40)", +"hsla(120, 37.5%, 25%)", "rgb(40, 88, 40)", +"hsla(150, 37.5%, 25%)", "rgb(40, 88, 64)", +"hsla(180, 37.5%, 25%)", "rgb(40, 88, 88)", +"hsla(210, 37.5%, 25%)", "rgb(40, 64, 88)", +"hsla(240, 37.5%, 25%)", "rgb(40, 40, 88)", +"hsla(270, 37.5%, 25%)", "rgb(64, 40, 88)", +"hsla(300, 37.5%, 25%)", "rgb(88, 40, 88)", +"hsla(330, 37.5%, 25%)", "rgb(88, 40, 64)", +"hsla(0, 50%, 25%)", "rgb(96, 32, 32)", +"hsla(30, 50%, 25%)", "rgb(96, 64, 32)", +"hsla(60, 50%, 25%)", "rgb(96, 96, 32)", +"hsla(90, 50%, 25%)", "rgb(64, 96, 32)", +"hsla(120, 50%, 25%)", "rgb(32, 96, 32)", +"hsla(150, 50%, 25%)", "rgb(32, 96, 64)", +"hsla(180, 50%, 25%)", "rgb(32, 96, 96)", +"hsla(210, 50%, 25%)", "rgb(32, 64, 96)", +"hsla(240, 50%, 25%)", "rgb(32, 32, 96)", +"hsla(270, 50%, 25%)", "rgb(64, 32, 96)", +"hsla(300, 50%, 25%)", "rgb(96, 32, 96)", +"hsla(330, 50%, 25%)", "rgb(96, 32, 64)", +"hsla(0, 62.5%, 25%)", "rgb(104, 24, 24)", +"hsla(30, 62.5%, 25%)", "rgb(104, 64, 24)", +"hsla(60, 62.5%, 25%)", "rgb(104, 104, 24)", +"hsla(90, 62.5%, 25%)", "rgb(64, 104, 24)", +"hsla(120, 62.5%, 25%)", "rgb(24, 104, 24)", +"hsla(150, 62.5%, 25%)", "rgb(24, 104, 64)", +"hsla(180, 62.5%, 25%)", "rgb(24, 104, 104)", +"hsla(210, 62.5%, 25%)", "rgb(24, 64, 104)", +"hsla(240, 62.5%, 25%)", "rgb(24, 24, 104)", +"hsla(270, 62.5%, 25%)", "rgb(64, 24, 104)", +"hsla(300, 62.5%, 25%)", "rgb(104, 24, 104)", +"hsla(330, 62.5%, 25%)", "rgb(104, 24, 64)", +"hsla(0, 75%, 25%)", "rgb(112, 16, 16)", +"hsla(30, 75%, 25%)", "rgb(112, 64, 16)", +"hsla(60, 75%, 25%)", "rgb(112, 112, 16)", +"hsla(90, 75%, 25%)", "rgb(64, 112, 16)", +"hsla(120, 75%, 25%)", "rgb(16, 112, 16)", +"hsla(150, 75%, 25%)", "rgb(16, 112, 64)", +"hsla(180, 75%, 25%)", "rgb(16, 112, 112)", +"hsla(210, 75%, 25%)", "rgb(16, 64, 112)", +"hsla(240, 75%, 25%)", "rgb(16, 16, 112)", +"hsla(270, 75%, 25%)", "rgb(64, 16, 112)", +"hsla(300, 75%, 25%)", "rgb(112, 16, 112)", +"hsla(330, 75%, 25%)", "rgb(112, 16, 64)", +"hsla(0, 87.5%, 25%)", "rgb(120, 8, 8)", +"hsla(30, 87.5%, 25%)", "rgb(120, 64, 8)", +"hsla(60, 87.5%, 25%)", "rgb(120, 120, 8)", +"hsla(90, 87.5%, 25%)", "rgb(64, 120, 8)", +"hsla(120, 87.5%, 25%)", "rgb(8, 120, 8)", +"hsla(150, 87.5%, 25%)", "rgb(8, 120, 64)", +"hsla(180, 87.5%, 25%)", "rgb(8, 120, 120)", +"hsla(210, 87.5%, 25%)", "rgb(8, 64, 120)", +"hsla(240, 87.5%, 25%)", "rgb(8, 8, 120)", +"hsla(270, 87.5%, 25%)", "rgb(64, 8, 120)", +"hsla(300, 87.5%, 25%)", "rgb(120, 8, 120)", +"hsla(330, 87.5%, 25%)", "rgb(120, 8, 64)", +"hsla(0, 100%, 25%)", "rgb(128, 0, 0)", +"hsla(30, 100%, 25%)", "rgb(128, 64, 0)", +"hsla(60, 100%, 25%)", "rgb(128, 128, 0)", +"hsla(90, 100%, 25%)", "rgb(64, 128, 0)", +"hsla(120, 100%, 25%)", "rgb(0, 128, 0)", +"hsla(150, 100%, 25%)", "rgb(0, 128, 64)", +"hsla(180, 100%, 25%)", "rgb(0, 128, 128)", +"hsla(210, 100%, 25%)", "rgb(0, 64, 128)", +"hsla(240, 100%, 25%)", "rgb(0, 0, 128)", +"hsla(270, 100%, 25%)", "rgb(64, 0, 128)", +"hsla(300, 100%, 25%)", "rgb(128, 0, 128)", +"hsla(330, 100%, 25%)", "rgb(128, 0, 64)", +"hsla(0, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(30, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(60, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(90, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(120, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(150, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(180, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(210, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(240, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(270, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(300, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(330, 0%, 37.5%)", "rgb(96, 96, 96)", +"hsla(0, 12.5%, 37.5%)", "rgb(108, 84, 84)", +"hsla(30, 12.5%, 37.5%)", "rgb(108, 96, 84)", +"hsla(60, 12.5%, 37.5%)", "rgb(108, 108, 84)", +"hsla(90, 12.5%, 37.5%)", "rgb(96, 108, 84)", +"hsla(120, 12.5%, 37.5%)", "rgb(84, 108, 84)", +"hsla(150, 12.5%, 37.5%)", "rgb(84, 108, 96)", +"hsla(180, 12.5%, 37.5%)", "rgb(84, 108, 108)", +"hsla(210, 12.5%, 37.5%)", "rgb(84, 96, 108)", +"hsla(240, 12.5%, 37.5%)", "rgb(84, 84, 108)", +"hsla(270, 12.5%, 37.5%)", "rgb(96, 84, 108)", +"hsla(300, 12.5%, 37.5%)", "rgb(108, 84, 108)", +"hsla(330, 12.5%, 37.5%)", "rgb(108, 84, 96)", +"hsla(0, 25%, 37.5%)", "rgb(120, 72, 72)", +"hsla(30, 25%, 37.5%)", "rgb(120, 96, 72)", +"hsla(60, 25%, 37.5%)", "rgb(120, 120, 72)", +"hsla(90, 25%, 37.5%)", "rgb(96, 120, 72)", +"hsla(120, 25%, 37.5%)", "rgb(72, 120, 72)", +"hsla(150, 25%, 37.5%)", "rgb(72, 120, 96)", +"hsla(180, 25%, 37.5%)", "rgb(72, 120, 120)", +"hsla(210, 25%, 37.5%)", "rgb(72, 96, 120)", +"hsla(240, 25%, 37.5%)", "rgb(72, 72, 120)", +"hsla(270, 25%, 37.5%)", "rgb(96, 72, 120)", +"hsla(300, 25%, 37.5%)", "rgb(120, 72, 120)", +"hsla(330, 25%, 37.5%)", "rgb(120, 72, 96)", +"hsla(0, 37.5%, 37.5%)", "rgb(131, 60, 60)", +"hsla(30, 37.5%, 37.5%)", "rgb(131, 96, 60)", +"hsla(60, 37.5%, 37.5%)", "rgb(131, 131, 60)", +"hsla(90, 37.5%, 37.5%)", "rgb(96, 131, 60)", +"hsla(120, 37.5%, 37.5%)", "rgb(60, 131, 60)", +"hsla(150, 37.5%, 37.5%)", "rgb(60, 131, 96)", +"hsla(180, 37.5%, 37.5%)", "rgb(60, 131, 131)", +"hsla(210, 37.5%, 37.5%)", "rgb(60, 96, 131)", +"hsla(240, 37.5%, 37.5%)", "rgb(60, 60, 131)", +"hsla(270, 37.5%, 37.5%)", "rgb(96, 60, 131)", +"hsla(300, 37.5%, 37.5%)", "rgb(131, 60, 131)", +"hsla(330, 37.5%, 37.5%)", "rgb(131, 60, 96)", +"hsla(0, 50%, 37.5%)", "rgb(143, 48, 48)", +"hsla(30, 50%, 37.5%)", "rgb(143, 96, 48)", +"hsla(60, 50%, 37.5%)", "rgb(143, 143, 48)", +"hsla(90, 50%, 37.5%)", "rgb(96, 143, 48)", +"hsla(120, 50%, 37.5%)", "rgb(48, 143, 48)", +"hsla(150, 50%, 37.5%)", "rgb(48, 143, 96)", +"hsla(180, 50%, 37.5%)", "rgb(48, 143, 143)", +"hsla(210, 50%, 37.5%)", "rgb(48, 96, 143)", +"hsla(240, 50%, 37.5%)", "rgb(48, 48, 143)", +"hsla(270, 50%, 37.5%)", "rgb(96, 48, 143)", +"hsla(300, 50%, 37.5%)", "rgb(143, 48, 143)", +"hsla(330, 50%, 37.5%)", "rgb(143, 48, 96)", +"hsla(0, 62.5%, 37.5%)", "rgb(155, 36, 36)", +"hsla(30, 62.5%, 37.5%)", "rgb(155, 96, 36)", +"hsla(60, 62.5%, 37.5%)", "rgb(155, 155, 36)", +"hsla(90, 62.5%, 37.5%)", "rgb(96, 155, 36)", +"hsla(120, 62.5%, 37.5%)", "rgb(36, 155, 36)", +"hsla(150, 62.5%, 37.5%)", "rgb(36, 155, 96)", +"hsla(180, 62.5%, 37.5%)", "rgb(36, 155, 155)", +"hsla(210, 62.5%, 37.5%)", "rgb(36, 96, 155)", +"hsla(240, 62.5%, 37.5%)", "rgb(36, 36, 155)", +"hsla(270, 62.5%, 37.5%)", "rgb(96, 36, 155)", +"hsla(300, 62.5%, 37.5%)", "rgb(155, 36, 155)", +"hsla(330, 62.5%, 37.5%)", "rgb(155, 36, 96)", +"hsla(0, 75%, 37.5%)", "rgb(167, 24, 24)", +"hsla(30, 75%, 37.5%)", "rgb(167, 96, 24)", +"hsla(60, 75%, 37.5%)", "rgb(167, 167, 24)", +"hsla(90, 75%, 37.5%)", "rgb(96, 167, 24)", +"hsla(120, 75%, 37.5%)", "rgb(24, 167, 24)", +"hsla(150, 75%, 37.5%)", "rgb(24, 167, 96)", +"hsla(180, 75%, 37.5%)", "rgb(24, 167, 167)", +"hsla(210, 75%, 37.5%)", "rgb(24, 96, 167)", +"hsla(240, 75%, 37.5%)", "rgb(24, 24, 167)", +"hsla(270, 75%, 37.5%)", "rgb(96, 24, 167)", +"hsla(300, 75%, 37.5%)", "rgb(167, 24, 167)", +"hsla(330, 75%, 37.5%)", "rgb(167, 24, 96)", +"hsla(0, 87.5%, 37.5%)", "rgb(179, 12, 12)", +"hsla(30, 87.5%, 37.5%)", "rgb(179, 96, 12)", +"hsla(60, 87.5%, 37.5%)", "rgb(179, 179, 12)", +"hsla(90, 87.5%, 37.5%)", "rgb(96, 179, 12)", +"hsla(120, 87.5%, 37.5%)", "rgb(12, 179, 12)", +"hsla(150, 87.5%, 37.5%)", "rgb(12, 179, 96)", +"hsla(180, 87.5%, 37.5%)", "rgb(12, 179, 179)", +"hsla(210, 87.5%, 37.5%)", "rgb(12, 96, 179)", +"hsla(240, 87.5%, 37.5%)", "rgb(12, 12, 179)", +"hsla(270, 87.5%, 37.5%)", "rgb(96, 12, 179)", +"hsla(300, 87.5%, 37.5%)", "rgb(179, 12, 179)", +"hsla(330, 87.5%, 37.5%)", "rgb(179, 12, 96)", +"hsla(0, 100%, 37.5%)", "rgb(191, 0, 0)", +"hsla(30, 100%, 37.5%)", "rgb(191, 96, 0)", +"hsla(60, 100%, 37.5%)", "rgb(191, 191, 0)", +"hsla(90, 100%, 37.5%)", "rgb(96, 191, 0)", +"hsla(120, 100%, 37.5%)", "rgb(0, 191, 0)", +"hsla(150, 100%, 37.5%)", "rgb(0, 191, 96)", +"hsla(180, 100%, 37.5%)", "rgb(0, 191, 191)", +"hsla(210, 100%, 37.5%)", "rgb(0, 96, 191)", +"hsla(240, 100%, 37.5%)", "rgb(0, 0, 191)", +"hsla(270, 100%, 37.5%)", "rgb(96, 0, 191)", +"hsla(300, 100%, 37.5%)", "rgb(191, 0, 191)", +"hsla(330, 100%, 37.5%)", "rgb(191, 0, 96)", +"hsla(0, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(30, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(60, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(90, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(120, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(150, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(180, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(210, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(240, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(270, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(300, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(330, 0%, 50%)", "rgb(128, 128, 128)", +"hsla(0, 12.5%, 50%)", "rgb(143, 112, 112)", +"hsla(30, 12.5%, 50%)", "rgb(143, 128, 112)", +"hsla(60, 12.5%, 50%)", "rgb(143, 143, 112)", +"hsla(90, 12.5%, 50%)", "rgb(128, 143, 112)", +"hsla(120, 12.5%, 50%)", "rgb(112, 143, 112)", +"hsla(150, 12.5%, 50%)", "rgb(112, 143, 128)", +"hsla(180, 12.5%, 50%)", "rgb(112, 143, 143)", +"hsla(210, 12.5%, 50%)", "rgb(112, 128, 143)", +"hsla(240, 12.5%, 50%)", "rgb(112, 112, 143)", +"hsla(270, 12.5%, 50%)", "rgb(128, 112, 143)", +"hsla(300, 12.5%, 50%)", "rgb(143, 112, 143)", +"hsla(330, 12.5%, 50%)", "rgb(143, 112, 128)", +"hsla(0, 25%, 50%)", "rgb(159, 96, 96)", +"hsla(30, 25%, 50%)", "rgb(159, 128, 96)", +"hsla(60, 25%, 50%)", "rgb(159, 159, 96)", +"hsla(90, 25%, 50%)", "rgb(128, 159, 96)", +"hsla(120, 25%, 50%)", "rgb(96, 159, 96)", +"hsla(150, 25%, 50%)", "rgb(96, 159, 128)", +"hsla(180, 25%, 50%)", "rgb(96, 159, 159)", +"hsla(210, 25%, 50%)", "rgb(96, 128, 159)", +"hsla(240, 25%, 50%)", "rgb(96, 96, 159)", +"hsla(270, 25%, 50%)", "rgb(128, 96, 159)", +"hsla(300, 25%, 50%)", "rgb(159, 96, 159)", +"hsla(330, 25%, 50%)", "rgb(159, 96, 128)", +"hsla(0, 37.5%, 50%)", "rgb(175, 80, 80)", +"hsla(30, 37.5%, 50%)", "rgb(175, 128, 80)", +"hsla(60, 37.5%, 50%)", "rgb(175, 175, 80)", +"hsla(90, 37.5%, 50%)", "rgb(128, 175, 80)", +"hsla(120, 37.5%, 50%)", "rgb(80, 175, 80)", +"hsla(150, 37.5%, 50%)", "rgb(80, 175, 128)", +"hsla(180, 37.5%, 50%)", "rgb(80, 175, 175)", +"hsla(210, 37.5%, 50%)", "rgb(80, 128, 175)", +"hsla(240, 37.5%, 50%)", "rgb(80, 80, 175)", +"hsla(270, 37.5%, 50%)", "rgb(128, 80, 175)", +"hsla(300, 37.5%, 50%)", "rgb(175, 80, 175)", +"hsla(330, 37.5%, 50%)", "rgb(175, 80, 128)", +"hsla(0, 50%, 50%)", "rgb(191, 64, 64)", +"hsla(30, 50%, 50%)", "rgb(191, 128, 64)", +"hsla(60, 50%, 50%)", "rgb(191, 191, 64)", +"hsla(90, 50%, 50%)", "rgb(128, 191, 64)", +"hsla(120, 50%, 50%)", "rgb(64, 191, 64)", +"hsla(150, 50%, 50%)", "rgb(64, 191, 128)", +"hsla(180, 50%, 50%)", "rgb(64, 191, 191)", +"hsla(210, 50%, 50%)", "rgb(64, 128, 191)", +"hsla(240, 50%, 50%)", "rgb(64, 64, 191)", +"hsla(270, 50%, 50%)", "rgb(128, 64, 191)", +"hsla(300, 50%, 50%)", "rgb(191, 64, 191)", +"hsla(330, 50%, 50%)", "rgb(191, 64, 128)", +"hsla(0, 62.5%, 50%)", "rgb(207, 48, 48)", +"hsla(30, 62.5%, 50%)", "rgb(207, 128, 48)", +"hsla(60, 62.5%, 50%)", "rgb(207, 207, 48)", +"hsla(90, 62.5%, 50%)", "rgb(128, 207, 48)", +"hsla(120, 62.5%, 50%)", "rgb(48, 207, 48)", +"hsla(150, 62.5%, 50%)", "rgb(48, 207, 128)", +"hsla(180, 62.5%, 50%)", "rgb(48, 207, 207)", +"hsla(210, 62.5%, 50%)", "rgb(48, 128, 207)", +"hsla(240, 62.5%, 50%)", "rgb(48, 48, 207)", +"hsla(270, 62.5%, 50%)", "rgb(128, 48, 207)", +"hsla(300, 62.5%, 50%)", "rgb(207, 48, 207)", +"hsla(330, 62.5%, 50%)", "rgb(207, 48, 128)", +"hsla(0, 75%, 50%)", "rgb(223, 32, 32)", +"hsla(30, 75%, 50%)", "rgb(223, 128, 32)", +"hsla(60, 75%, 50%)", "rgb(223, 223, 32)", +"hsla(90, 75%, 50%)", "rgb(128, 223, 32)", +"hsla(120, 75%, 50%)", "rgb(32, 223, 32)", +"hsla(150, 75%, 50%)", "rgb(32, 223, 128)", +"hsla(180, 75%, 50%)", "rgb(32, 223, 223)", +"hsla(210, 75%, 50%)", "rgb(32, 128, 223)", +"hsla(240, 75%, 50%)", "rgb(32, 32, 223)", +"hsla(270, 75%, 50%)", "rgb(128, 32, 223)", +"hsla(300, 75%, 50%)", "rgb(223, 32, 223)", +"hsla(330, 75%, 50%)", "rgb(223, 32, 128)", +"hsla(0, 87.5%, 50%)", "rgb(239, 16, 16)", +"hsla(30, 87.5%, 50%)", "rgb(239, 128, 16)", +"hsla(60, 87.5%, 50%)", "rgb(239, 239, 16)", +"hsla(90, 87.5%, 50%)", "rgb(128, 239, 16)", +"hsla(120, 87.5%, 50%)", "rgb(16, 239, 16)", +"hsla(150, 87.5%, 50%)", "rgb(16, 239, 128)", +"hsla(180, 87.5%, 50%)", "rgb(16, 239, 239)", +"hsla(210, 87.5%, 50%)", "rgb(16, 128, 239)", +"hsla(240, 87.5%, 50%)", "rgb(16, 16, 239)", +"hsla(270, 87.5%, 50%)", "rgb(128, 16, 239)", +"hsla(300, 87.5%, 50%)", "rgb(239, 16, 239)", +"hsla(330, 87.5%, 50%)", "rgb(239, 16, 128)", +"hsla(0, 100%, 50%)", "rgb(255, 0, 0)", +"hsla(30, 100%, 50%)", "rgb(255, 128, 0)", +"hsla(60, 100%, 50%)", "rgb(255, 255, 0)", +"hsla(90, 100%, 50%)", "rgb(128, 255, 0)", +"hsla(120, 100%, 50%)", "rgb(0, 255, 0)", +"hsla(150, 100%, 50%)", "rgb(0, 255, 128)", +"hsla(180, 100%, 50%)", "rgb(0, 255, 255)", +"hsla(210, 100%, 50%)", "rgb(0, 128, 255)", +"hsla(240, 100%, 50%)", "rgb(0, 0, 255)", +"hsla(270, 100%, 50%)", "rgb(128, 0, 255)", +"hsla(300, 100%, 50%)", "rgb(255, 0, 255)", +"hsla(330, 100%, 50%)", "rgb(255, 0, 128)", +"hsla(0, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(30, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(60, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(90, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(120, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(150, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(180, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(210, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(240, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(270, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(300, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(330, 0%, 62.5%)", "rgb(159, 159, 159)", +"hsla(0, 12.5%, 62.5%)", "rgb(171, 147, 147)", +"hsla(30, 12.5%, 62.5%)", "rgb(171, 159, 147)", +"hsla(60, 12.5%, 62.5%)", "rgb(171, 171, 147)", +"hsla(90, 12.5%, 62.5%)", "rgb(159, 171, 147)", +"hsla(120, 12.5%, 62.5%)", "rgb(147, 171, 147)", +"hsla(150, 12.5%, 62.5%)", "rgb(147, 171, 159)", +"hsla(180, 12.5%, 62.5%)", "rgb(147, 171, 171)", +"hsla(210, 12.5%, 62.5%)", "rgb(147, 159, 171)", +"hsla(240, 12.5%, 62.5%)", "rgb(147, 147, 171)", +"hsla(270, 12.5%, 62.5%)", "rgb(159, 147, 171)", +"hsla(300, 12.5%, 62.5%)", "rgb(171, 147, 171)", +"hsla(330, 12.5%, 62.5%)", "rgb(171, 147, 159)", +"hsla(0, 25%, 62.5%)", "rgb(183, 135, 135)", +"hsla(30, 25%, 62.5%)", "rgb(183, 159, 135)", +"hsla(60, 25%, 62.5%)", "rgb(183, 183, 135)", +"hsla(90, 25%, 62.5%)", "rgb(159, 183, 135)", +"hsla(120, 25%, 62.5%)", "rgb(135, 183, 135)", +"hsla(150, 25%, 62.5%)", "rgb(135, 183, 159)", +"hsla(180, 25%, 62.5%)", "rgb(135, 183, 183)", +"hsla(210, 25%, 62.5%)", "rgb(135, 159, 183)", +"hsla(240, 25%, 62.5%)", "rgb(135, 135, 183)", +"hsla(270, 25%, 62.5%)", "rgb(159, 135, 183)", +"hsla(300, 25%, 62.5%)", "rgb(183, 135, 183)", +"hsla(330, 25%, 62.5%)", "rgb(183, 135, 159)", +"hsla(0, 37.5%, 62.5%)", "rgb(195, 124, 124)", +"hsla(30, 37.5%, 62.5%)", "rgb(195, 159, 124)", +"hsla(60, 37.5%, 62.5%)", "rgb(195, 195, 124)", +"hsla(90, 37.5%, 62.5%)", "rgb(159, 195, 124)", +"hsla(120, 37.5%, 62.5%)", "rgb(124, 195, 124)", +"hsla(150, 37.5%, 62.5%)", "rgb(124, 195, 159)", +"hsla(180, 37.5%, 62.5%)", "rgb(124, 195, 195)", +"hsla(210, 37.5%, 62.5%)", "rgb(124, 159, 195)", +"hsla(240, 37.5%, 62.5%)", "rgb(124, 124, 195)", +"hsla(270, 37.5%, 62.5%)", "rgb(159, 124, 195)", +"hsla(300, 37.5%, 62.5%)", "rgb(195, 124, 195)", +"hsla(330, 37.5%, 62.5%)", "rgb(195, 124, 159)", +"hsla(0, 50%, 62.5%)", "rgb(207, 112, 112)", +"hsla(30, 50%, 62.5%)", "rgb(207, 159, 112)", +"hsla(60, 50%, 62.5%)", "rgb(207, 207, 112)", +"hsla(90, 50%, 62.5%)", "rgb(159, 207, 112)", +"hsla(120, 50%, 62.5%)", "rgb(112, 207, 112)", +"hsla(150, 50%, 62.5%)", "rgb(112, 207, 159)", +"hsla(180, 50%, 62.5%)", "rgb(112, 207, 207)", +"hsla(210, 50%, 62.5%)", "rgb(112, 159, 207)", +"hsla(240, 50%, 62.5%)", "rgb(112, 112, 207)", +"hsla(270, 50%, 62.5%)", "rgb(159, 112, 207)", +"hsla(300, 50%, 62.5%)", "rgb(207, 112, 207)", +"hsla(330, 50%, 62.5%)", "rgb(207, 112, 159)", +"hsla(0, 62.5%, 62.5%)", "rgb(219, 100, 100)", +"hsla(30, 62.5%, 62.5%)", "rgb(219, 159, 100)", +"hsla(60, 62.5%, 62.5%)", "rgb(219, 219, 100)", +"hsla(90, 62.5%, 62.5%)", "rgb(159, 219, 100)", +"hsla(120, 62.5%, 62.5%)", "rgb(100, 219, 100)", +"hsla(150, 62.5%, 62.5%)", "rgb(100, 219, 159)", +"hsla(180, 62.5%, 62.5%)", "rgb(100, 219, 219)", +"hsla(210, 62.5%, 62.5%)", "rgb(100, 159, 219)", +"hsla(240, 62.5%, 62.5%)", "rgb(100, 100, 219)", +"hsla(270, 62.5%, 62.5%)", "rgb(159, 100, 219)", +"hsla(300, 62.5%, 62.5%)", "rgb(219, 100, 219)", +"hsla(330, 62.5%, 62.5%)", "rgb(219, 100, 159)", +"hsla(0, 75%, 62.5%)", "rgb(231, 88, 88)", +"hsla(30, 75%, 62.5%)", "rgb(231, 159, 88)", +"hsla(60, 75%, 62.5%)", "rgb(231, 231, 88)", +"hsla(90, 75%, 62.5%)", "rgb(159, 231, 88)", +"hsla(120, 75%, 62.5%)", "rgb(88, 231, 88)", +"hsla(150, 75%, 62.5%)", "rgb(88, 231, 159)", +"hsla(180, 75%, 62.5%)", "rgb(88, 231, 231)", +"hsla(210, 75%, 62.5%)", "rgb(88, 159, 231)", +"hsla(240, 75%, 62.5%)", "rgb(88, 88, 231)", +"hsla(270, 75%, 62.5%)", "rgb(159, 88, 231)", +"hsla(300, 75%, 62.5%)", "rgb(231, 88, 231)", +"hsla(330, 75%, 62.5%)", "rgb(231, 88, 159)", +"hsla(0, 87.5%, 62.5%)", "rgb(243, 76, 76)", +"hsla(30, 87.5%, 62.5%)", "rgb(243, 159, 76)", +"hsla(60, 87.5%, 62.5%)", "rgb(243, 243, 76)", +"hsla(90, 87.5%, 62.5%)", "rgb(159, 243, 76)", +"hsla(120, 87.5%, 62.5%)", "rgb(76, 243, 76)", +"hsla(150, 87.5%, 62.5%)", "rgb(76, 243, 159)", +"hsla(180, 87.5%, 62.5%)", "rgb(76, 243, 243)", +"hsla(210, 87.5%, 62.5%)", "rgb(76, 159, 243)", +"hsla(240, 87.5%, 62.5%)", "rgb(76, 76, 243)", +"hsla(270, 87.5%, 62.5%)", "rgb(159, 76, 243)", +"hsla(300, 87.5%, 62.5%)", "rgb(243, 76, 243)", +"hsla(330, 87.5%, 62.5%)", "rgb(243, 76, 159)", +"hsla(0, 100%, 62.5%)", "rgb(255, 64, 64)", +"hsla(30, 100%, 62.5%)", "rgb(255, 159, 64)", +"hsla(60, 100%, 62.5%)", "rgb(255, 255, 64)", +"hsla(90, 100%, 62.5%)", "rgb(159, 255, 64)", +"hsla(120, 100%, 62.5%)", "rgb(64, 255, 64)", +"hsla(150, 100%, 62.5%)", "rgb(64, 255, 159)", +"hsla(180, 100%, 62.5%)", "rgb(64, 255, 255)", +"hsla(210, 100%, 62.5%)", "rgb(64, 159, 255)", +"hsla(240, 100%, 62.5%)", "rgb(64, 64, 255)", +"hsla(270, 100%, 62.5%)", "rgb(159, 64, 255)", +"hsla(300, 100%, 62.5%)", "rgb(255, 64, 255)", +"hsla(330, 100%, 62.5%)", "rgb(255, 64, 159)", +"hsla(0, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(30, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(60, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(90, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(120, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(150, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(180, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(210, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(240, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(270, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(300, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(330, 0%, 75%)", "rgb(191, 191, 191)", +"hsla(0, 12.5%, 75%)", "rgb(199, 183, 183)", +"hsla(30, 12.5%, 75%)", "rgb(199, 191, 183)", +"hsla(60, 12.5%, 75%)", "rgb(199, 199, 183)", +"hsla(90, 12.5%, 75%)", "rgb(191, 199, 183)", +"hsla(120, 12.5%, 75%)", "rgb(183, 199, 183)", +"hsla(150, 12.5%, 75%)", "rgb(183, 199, 191)", +"hsla(180, 12.5%, 75%)", "rgb(183, 199, 199)", +"hsla(210, 12.5%, 75%)", "rgb(183, 191, 199)", +"hsla(240, 12.5%, 75%)", "rgb(183, 183, 199)", +"hsla(270, 12.5%, 75%)", "rgb(191, 183, 199)", +"hsla(300, 12.5%, 75%)", "rgb(199, 183, 199)", +"hsla(330, 12.5%, 75%)", "rgb(199, 183, 191)", +"hsla(0, 25%, 75%)", "rgb(207, 175, 175)", +"hsla(30, 25%, 75%)", "rgb(207, 191, 175)", +"hsla(60, 25%, 75%)", "rgb(207, 207, 175)", +"hsla(90, 25%, 75%)", "rgb(191, 207, 175)", +"hsla(120, 25%, 75%)", "rgb(175, 207, 175)", +"hsla(150, 25%, 75%)", "rgb(175, 207, 191)", +"hsla(180, 25%, 75%)", "rgb(175, 207, 207)", +"hsla(210, 25%, 75%)", "rgb(175, 191, 207)", +"hsla(240, 25%, 75%)", "rgb(175, 175, 207)", +"hsla(270, 25%, 75%)", "rgb(191, 175, 207)", +"hsla(300, 25%, 75%)", "rgb(207, 175, 207)", +"hsla(330, 25%, 75%)", "rgb(207, 175, 191)", +"hsla(0, 37.5%, 75%)", "rgb(215, 167, 167)", +"hsla(30, 37.5%, 75%)", "rgb(215, 191, 167)", +"hsla(60, 37.5%, 75%)", "rgb(215, 215, 167)", +"hsla(90, 37.5%, 75%)", "rgb(191, 215, 167)", +"hsla(120, 37.5%, 75%)", "rgb(167, 215, 167)", +"hsla(150, 37.5%, 75%)", "rgb(167, 215, 191)", +"hsla(180, 37.5%, 75%)", "rgb(167, 215, 215)", +"hsla(210, 37.5%, 75%)", "rgb(167, 191, 215)", +"hsla(240, 37.5%, 75%)", "rgb(167, 167, 215)", +"hsla(270, 37.5%, 75%)", "rgb(191, 167, 215)", +"hsla(300, 37.5%, 75%)", "rgb(215, 167, 215)", +"hsla(330, 37.5%, 75%)", "rgb(215, 167, 191)", +"hsla(0, 50%, 75%)", "rgb(223, 159, 159)", +"hsla(30, 50%, 75%)", "rgb(223, 191, 159)", +"hsla(60, 50%, 75%)", "rgb(223, 223, 159)", +"hsla(90, 50%, 75%)", "rgb(191, 223, 159)", +"hsla(120, 50%, 75%)", "rgb(159, 223, 159)", +"hsla(150, 50%, 75%)", "rgb(159, 223, 191)", +"hsla(180, 50%, 75%)", "rgb(159, 223, 223)", +"hsla(210, 50%, 75%)", "rgb(159, 191, 223)", +"hsla(240, 50%, 75%)", "rgb(159, 159, 223)", +"hsla(270, 50%, 75%)", "rgb(191, 159, 223)", +"hsla(300, 50%, 75%)", "rgb(223, 159, 223)", +"hsla(330, 50%, 75%)", "rgb(223, 159, 191)", +"hsla(0, 62.5%, 75%)", "rgb(231, 151, 151)", +"hsla(30, 62.5%, 75%)", "rgb(231, 191, 151)", +"hsla(60, 62.5%, 75%)", "rgb(231, 231, 151)", +"hsla(90, 62.5%, 75%)", "rgb(191, 231, 151)", +"hsla(120, 62.5%, 75%)", "rgb(151, 231, 151)", +"hsla(150, 62.5%, 75%)", "rgb(151, 231, 191)", +"hsla(180, 62.5%, 75%)", "rgb(151, 231, 231)", +"hsla(210, 62.5%, 75%)", "rgb(151, 191, 231)", +"hsla(240, 62.5%, 75%)", "rgb(151, 151, 231)", +"hsla(270, 62.5%, 75%)", "rgb(191, 151, 231)", +"hsla(300, 62.5%, 75%)", "rgb(231, 151, 231)", +"hsla(330, 62.5%, 75%)", "rgb(231, 151, 191)", +"hsla(0, 75%, 75%)", "rgb(239, 143, 143)", +"hsla(30, 75%, 75%)", "rgb(239, 191, 143)", +"hsla(60, 75%, 75%)", "rgb(239, 239, 143)", +"hsla(90, 75%, 75%)", "rgb(191, 239, 143)", +"hsla(120, 75%, 75%)", "rgb(143, 239, 143)", +"hsla(150, 75%, 75%)", "rgb(143, 239, 191)", +"hsla(180, 75%, 75%)", "rgb(143, 239, 239)", +"hsla(210, 75%, 75%)", "rgb(143, 191, 239)", +"hsla(240, 75%, 75%)", "rgb(143, 143, 239)", +"hsla(270, 75%, 75%)", "rgb(191, 143, 239)", +"hsla(300, 75%, 75%)", "rgb(239, 143, 239)", +"hsla(330, 75%, 75%)", "rgb(239, 143, 191)", +"hsla(0, 87.5%, 75%)", "rgb(247, 135, 135)", +"hsla(30, 87.5%, 75%)", "rgb(247, 191, 135)", +"hsla(60, 87.5%, 75%)", "rgb(247, 247, 135)", +"hsla(90, 87.5%, 75%)", "rgb(191, 247, 135)", +"hsla(120, 87.5%, 75%)", "rgb(135, 247, 135)", +"hsla(150, 87.5%, 75%)", "rgb(135, 247, 191)", +"hsla(180, 87.5%, 75%)", "rgb(135, 247, 247)", +"hsla(210, 87.5%, 75%)", "rgb(135, 191, 247)", +"hsla(240, 87.5%, 75%)", "rgb(135, 135, 247)", +"hsla(270, 87.5%, 75%)", "rgb(191, 135, 247)", +"hsla(300, 87.5%, 75%)", "rgb(247, 135, 247)", +"hsla(330, 87.5%, 75%)", "rgb(247, 135, 191)", +"hsla(0, 100%, 75%)", "rgb(255, 128, 128)", +"hsla(30, 100%, 75%)", "rgb(255, 191, 128)", +"hsla(60, 100%, 75%)", "rgb(255, 255, 128)", +"hsla(90, 100%, 75%)", "rgb(191, 255, 128)", +"hsla(120, 100%, 75%)", "rgb(128, 255, 128)", +"hsla(150, 100%, 75%)", "rgb(128, 255, 191)", +"hsla(180, 100%, 75%)", "rgb(128, 255, 255)", +"hsla(210, 100%, 75%)", "rgb(128, 191, 255)", +"hsla(240, 100%, 75%)", "rgb(128, 128, 255)", +"hsla(270, 100%, 75%)", "rgb(191, 128, 255)", +"hsla(300, 100%, 75%)", "rgb(255, 128, 255)", +"hsla(330, 100%, 75%)", "rgb(255, 128, 191)", +"hsla(0, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(30, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(60, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(90, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(120, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(150, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(180, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(210, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(240, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(270, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(300, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(330, 0%, 87.5%)", "rgb(223, 223, 223)", +"hsla(0, 12.5%, 87.5%)", "rgb(227, 219, 219)", +"hsla(30, 12.5%, 87.5%)", "rgb(227, 223, 219)", +"hsla(60, 12.5%, 87.5%)", "rgb(227, 227, 219)", +"hsla(90, 12.5%, 87.5%)", "rgb(223, 227, 219)", +"hsla(120, 12.5%, 87.5%)", "rgb(219, 227, 219)", +"hsla(150, 12.5%, 87.5%)", "rgb(219, 227, 223)", +"hsla(180, 12.5%, 87.5%)", "rgb(219, 227, 227)", +"hsla(210, 12.5%, 87.5%)", "rgb(219, 223, 227)", +"hsla(240, 12.5%, 87.5%)", "rgb(219, 219, 227)", +"hsla(270, 12.5%, 87.5%)", "rgb(223, 219, 227)", +"hsla(300, 12.5%, 87.5%)", "rgb(227, 219, 227)", +"hsla(330, 12.5%, 87.5%)", "rgb(227, 219, 223)", +"hsla(0, 25%, 87.5%)", "rgb(231, 215, 215)", +"hsla(30, 25%, 87.5%)", "rgb(231, 223, 215)", +"hsla(60, 25%, 87.5%)", "rgb(231, 231, 215)", +"hsla(90, 25%, 87.5%)", "rgb(223, 231, 215)", +"hsla(120, 25%, 87.5%)", "rgb(215, 231, 215)", +"hsla(150, 25%, 87.5%)", "rgb(215, 231, 223)", +"hsla(180, 25%, 87.5%)", "rgb(215, 231, 231)", +"hsla(210, 25%, 87.5%)", "rgb(215, 223, 231)", +"hsla(240, 25%, 87.5%)", "rgb(215, 215, 231)", +"hsla(270, 25%, 87.5%)", "rgb(223, 215, 231)", +"hsla(300, 25%, 87.5%)", "rgb(231, 215, 231)", +"hsla(330, 25%, 87.5%)", "rgb(231, 215, 223)", +"hsla(0, 37.5%, 87.5%)", "rgb(235, 211, 211)", +"hsla(30, 37.5%, 87.5%)", "rgb(235, 223, 211)", +"hsla(60, 37.5%, 87.5%)", "rgb(235, 235, 211)", +"hsla(90, 37.5%, 87.5%)", "rgb(223, 235, 211)", +"hsla(120, 37.5%, 87.5%)", "rgb(211, 235, 211)", +"hsla(150, 37.5%, 87.5%)", "rgb(211, 235, 223)", +"hsla(180, 37.5%, 87.5%)", "rgb(211, 235, 235)", +"hsla(210, 37.5%, 87.5%)", "rgb(211, 223, 235)", +"hsla(240, 37.5%, 87.5%)", "rgb(211, 211, 235)", +"hsla(270, 37.5%, 87.5%)", "rgb(223, 211, 235)", +"hsla(300, 37.5%, 87.5%)", "rgb(235, 211, 235)", +"hsla(330, 37.5%, 87.5%)", "rgb(235, 211, 223)", +"hsla(0, 50%, 87.5%)", "rgb(239, 207, 207)", +"hsla(30, 50%, 87.5%)", "rgb(239, 223, 207)", +"hsla(60, 50%, 87.5%)", "rgb(239, 239, 207)", +"hsla(90, 50%, 87.5%)", "rgb(223, 239, 207)", +"hsla(120, 50%, 87.5%)", "rgb(207, 239, 207)", +"hsla(150, 50%, 87.5%)", "rgb(207, 239, 223)", +"hsla(180, 50%, 87.5%)", "rgb(207, 239, 239)", +"hsla(210, 50%, 87.5%)", "rgb(207, 223, 239)", +"hsla(240, 50%, 87.5%)", "rgb(207, 207, 239)", +"hsla(270, 50%, 87.5%)", "rgb(223, 207, 239)", +"hsla(300, 50%, 87.5%)", "rgb(239, 207, 239)", +"hsla(330, 50%, 87.5%)", "rgb(239, 207, 223)", +"hsla(0, 62.5%, 87.5%)", "rgb(243, 203, 203)", +"hsla(30, 62.5%, 87.5%)", "rgb(243, 223, 203)", +"hsla(60, 62.5%, 87.5%)", "rgb(243, 243, 203)", +"hsla(90, 62.5%, 87.5%)", "rgb(223, 243, 203)", +"hsla(120, 62.5%, 87.5%)", "rgb(203, 243, 203)", +"hsla(150, 62.5%, 87.5%)", "rgb(203, 243, 223)", +"hsla(180, 62.5%, 87.5%)", "rgb(203, 243, 243)", +"hsla(210, 62.5%, 87.5%)", "rgb(203, 223, 243)", +"hsla(240, 62.5%, 87.5%)", "rgb(203, 203, 243)", +"hsla(270, 62.5%, 87.5%)", "rgb(223, 203, 243)", +"hsla(300, 62.5%, 87.5%)", "rgb(243, 203, 243)", +"hsla(330, 62.5%, 87.5%)", "rgb(243, 203, 223)", +"hsla(0, 75%, 87.5%)", "rgb(247, 199, 199)", +"hsla(30, 75%, 87.5%)", "rgb(247, 223, 199)", +"hsla(60, 75%, 87.5%)", "rgb(247, 247, 199)", +"hsla(90, 75%, 87.5%)", "rgb(223, 247, 199)", +"hsla(120, 75%, 87.5%)", "rgb(199, 247, 199)", +"hsla(150, 75%, 87.5%)", "rgb(199, 247, 223)", +"hsla(180, 75%, 87.5%)", "rgb(199, 247, 247)", +"hsla(210, 75%, 87.5%)", "rgb(199, 223, 247)", +"hsla(240, 75%, 87.5%)", "rgb(199, 199, 247)", +"hsla(270, 75%, 87.5%)", "rgb(223, 199, 247)", +"hsla(300, 75%, 87.5%)", "rgb(247, 199, 247)", +"hsla(330, 75%, 87.5%)", "rgb(247, 199, 223)", +"hsla(0, 87.5%, 87.5%)", "rgb(251, 195, 195)", +"hsla(30, 87.5%, 87.5%)", "rgb(251, 223, 195)", +"hsla(60, 87.5%, 87.5%)", "rgb(251, 251, 195)", +"hsla(90, 87.5%, 87.5%)", "rgb(223, 251, 195)", +"hsla(120, 87.5%, 87.5%)", "rgb(195, 251, 195)", +"hsla(150, 87.5%, 87.5%)", "rgb(195, 251, 223)", +"hsla(180, 87.5%, 87.5%)", "rgb(195, 251, 251)", +"hsla(210, 87.5%, 87.5%)", "rgb(195, 223, 251)", +"hsla(240, 87.5%, 87.5%)", "rgb(195, 195, 251)", +"hsla(270, 87.5%, 87.5%)", "rgb(223, 195, 251)", +"hsla(300, 87.5%, 87.5%)", "rgb(251, 195, 251)", +"hsla(330, 87.5%, 87.5%)", "rgb(251, 195, 223)", +"hsla(0, 100%, 87.5%)", "rgb(255, 191, 191)", +"hsla(30, 100%, 87.5%)", "rgb(255, 223, 191)", +"hsla(60, 100%, 87.5%)", "rgb(255, 255, 191)", +"hsla(90, 100%, 87.5%)", "rgb(223, 255, 191)", +"hsla(120, 100%, 87.5%)", "rgb(191, 255, 191)", +"hsla(150, 100%, 87.5%)", "rgb(191, 255, 223)", +"hsla(180, 100%, 87.5%)", "rgb(191, 255, 255)", +"hsla(210, 100%, 87.5%)", "rgb(191, 223, 255)", +"hsla(240, 100%, 87.5%)", "rgb(191, 191, 255)", +"hsla(270, 100%, 87.5%)", "rgb(223, 191, 255)", +"hsla(300, 100%, 87.5%)", "rgb(255, 191, 255)", +"hsla(330, 100%, 87.5%)", "rgb(255, 191, 223)", +"hsla(0, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 0%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 12.5%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 25%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 37.5%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 50%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 62.5%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 75%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 87.5%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(30, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(60, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(90, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(120, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(150, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(180, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(210, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(240, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(270, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(300, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(330, 100%, 100%)", "rgb(255, 255, 255)", +"hsla(0, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 0%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 12.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 25%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 37.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 50%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 62.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 75%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 87.5%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(30, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(60, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(90, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(120, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(150, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(180, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(210, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(240, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(270, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(300, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(330, 100%, 0%, 1.0)", "rgb(0, 0, 0)", +"hsla(0, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(30, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(60, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(90, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(120, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(150, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(180, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(210, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(240, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(270, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(300, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(330, 0%, 12.5%, 1.0)", "rgb(32, 32, 32)", +"hsla(0, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 28)", +"hsla(30, 12.5%, 12.5%, 1.0)", "rgb(36, 32, 28)", +"hsla(60, 12.5%, 12.5%, 1.0)", "rgb(36, 36, 28)", +"hsla(90, 12.5%, 12.5%, 1.0)", "rgb(32, 36, 28)", +"hsla(120, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 28)", +"hsla(150, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 32)", +"hsla(180, 12.5%, 12.5%, 1.0)", "rgb(28, 36, 36)", +"hsla(210, 12.5%, 12.5%, 1.0)", "rgb(28, 32, 36)", +"hsla(240, 12.5%, 12.5%, 1.0)", "rgb(28, 28, 36)", +"hsla(270, 12.5%, 12.5%, 1.0)", "rgb(32, 28, 36)", +"hsla(300, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 36)", +"hsla(330, 12.5%, 12.5%, 1.0)", "rgb(36, 28, 32)", +"hsla(0, 25%, 12.5%, 1.0)", "rgb(40, 24, 24)", +"hsla(30, 25%, 12.5%, 1.0)", "rgb(40, 32, 24)", +"hsla(60, 25%, 12.5%, 1.0)", "rgb(40, 40, 24)", +"hsla(90, 25%, 12.5%, 1.0)", "rgb(32, 40, 24)", +"hsla(120, 25%, 12.5%, 1.0)", "rgb(24, 40, 24)", +"hsla(150, 25%, 12.5%, 1.0)", "rgb(24, 40, 32)", +"hsla(180, 25%, 12.5%, 1.0)", "rgb(24, 40, 40)", +"hsla(210, 25%, 12.5%, 1.0)", "rgb(24, 32, 40)", +"hsla(240, 25%, 12.5%, 1.0)", "rgb(24, 24, 40)", +"hsla(270, 25%, 12.5%, 1.0)", "rgb(32, 24, 40)", +"hsla(300, 25%, 12.5%, 1.0)", "rgb(40, 24, 40)", +"hsla(330, 25%, 12.5%, 1.0)", "rgb(40, 24, 32)", +"hsla(0, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 20)", +"hsla(30, 37.5%, 12.5%, 1.0)", "rgb(44, 32, 20)", +"hsla(60, 37.5%, 12.5%, 1.0)", "rgb(44, 44, 20)", +"hsla(90, 37.5%, 12.5%, 1.0)", "rgb(32, 44, 20)", +"hsla(120, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 20)", +"hsla(150, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 32)", +"hsla(180, 37.5%, 12.5%, 1.0)", "rgb(20, 44, 44)", +"hsla(210, 37.5%, 12.5%, 1.0)", "rgb(20, 32, 44)", +"hsla(240, 37.5%, 12.5%, 1.0)", "rgb(20, 20, 44)", +"hsla(270, 37.5%, 12.5%, 1.0)", "rgb(32, 20, 44)", +"hsla(300, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 44)", +"hsla(330, 37.5%, 12.5%, 1.0)", "rgb(44, 20, 32)", +"hsla(0, 50%, 12.5%, 1.0)", "rgb(48, 16, 16)", +"hsla(30, 50%, 12.5%, 1.0)", "rgb(48, 32, 16)", +"hsla(60, 50%, 12.5%, 1.0)", "rgb(48, 48, 16)", +"hsla(90, 50%, 12.5%, 1.0)", "rgb(32, 48, 16)", +"hsla(120, 50%, 12.5%, 1.0)", "rgb(16, 48, 16)", +"hsla(150, 50%, 12.5%, 1.0)", "rgb(16, 48, 32)", +"hsla(180, 50%, 12.5%, 1.0)", "rgb(16, 48, 48)", +"hsla(210, 50%, 12.5%, 1.0)", "rgb(16, 32, 48)", +"hsla(240, 50%, 12.5%, 1.0)", "rgb(16, 16, 48)", +"hsla(270, 50%, 12.5%, 1.0)", "rgb(32, 16, 48)", +"hsla(300, 50%, 12.5%, 1.0)", "rgb(48, 16, 48)", +"hsla(330, 50%, 12.5%, 1.0)", "rgb(48, 16, 32)", +"hsla(0, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 12)", +"hsla(30, 62.5%, 12.5%, 1.0)", "rgb(52, 32, 12)", +"hsla(60, 62.5%, 12.5%, 1.0)", "rgb(52, 52, 12)", +"hsla(90, 62.5%, 12.5%, 1.0)", "rgb(32, 52, 12)", +"hsla(120, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 12)", +"hsla(150, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 32)", +"hsla(180, 62.5%, 12.5%, 1.0)", "rgb(12, 52, 52)", +"hsla(210, 62.5%, 12.5%, 1.0)", "rgb(12, 32, 52)", +"hsla(240, 62.5%, 12.5%, 1.0)", "rgb(12, 12, 52)", +"hsla(270, 62.5%, 12.5%, 1.0)", "rgb(32, 12, 52)", +"hsla(300, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 52)", +"hsla(330, 62.5%, 12.5%, 1.0)", "rgb(52, 12, 32)", +"hsla(0, 75%, 12.5%, 1.0)", "rgb(56, 8, 8)", +"hsla(30, 75%, 12.5%, 1.0)", "rgb(56, 32, 8)", +"hsla(60, 75%, 12.5%, 1.0)", "rgb(56, 56, 8)", +"hsla(90, 75%, 12.5%, 1.0)", "rgb(32, 56, 8)", +"hsla(120, 75%, 12.5%, 1.0)", "rgb(8, 56, 8)", +"hsla(150, 75%, 12.5%, 1.0)", "rgb(8, 56, 32)", +"hsla(180, 75%, 12.5%, 1.0)", "rgb(8, 56, 56)", +"hsla(210, 75%, 12.5%, 1.0)", "rgb(8, 32, 56)", +"hsla(240, 75%, 12.5%, 1.0)", "rgb(8, 8, 56)", +"hsla(270, 75%, 12.5%, 1.0)", "rgb(32, 8, 56)", +"hsla(300, 75%, 12.5%, 1.0)", "rgb(56, 8, 56)", +"hsla(330, 75%, 12.5%, 1.0)", "rgb(56, 8, 32)", +"hsla(0, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 4)", +"hsla(30, 87.5%, 12.5%, 1.0)", "rgb(60, 32, 4)", +"hsla(60, 87.5%, 12.5%, 1.0)", "rgb(60, 60, 4)", +"hsla(90, 87.5%, 12.5%, 1.0)", "rgb(32, 60, 4)", +"hsla(120, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 4)", +"hsla(150, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 32)", +"hsla(180, 87.5%, 12.5%, 1.0)", "rgb(4, 60, 60)", +"hsla(210, 87.5%, 12.5%, 1.0)", "rgb(4, 32, 60)", +"hsla(240, 87.5%, 12.5%, 1.0)", "rgb(4, 4, 60)", +"hsla(270, 87.5%, 12.5%, 1.0)", "rgb(32, 4, 60)", +"hsla(300, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 60)", +"hsla(330, 87.5%, 12.5%, 1.0)", "rgb(60, 4, 32)", +"hsla(0, 100%, 12.5%, 1.0)", "rgb(64, 0, 0)", +"hsla(30, 100%, 12.5%, 1.0)", "rgb(64, 32, 0)", +"hsla(60, 100%, 12.5%, 1.0)", "rgb(64, 64, 0)", +"hsla(90, 100%, 12.5%, 1.0)", "rgb(32, 64, 0)", +"hsla(120, 100%, 12.5%, 1.0)", "rgb(0, 64, 0)", +"hsla(150, 100%, 12.5%, 1.0)", "rgb(0, 64, 32)", +"hsla(180, 100%, 12.5%, 1.0)", "rgb(0, 64, 64)", +"hsla(210, 100%, 12.5%, 1.0)", "rgb(0, 32, 64)", +"hsla(240, 100%, 12.5%, 1.0)", "rgb(0, 0, 64)", +"hsla(270, 100%, 12.5%, 1.0)", "rgb(32, 0, 64)", +"hsla(300, 100%, 12.5%, 1.0)", "rgb(64, 0, 64)", +"hsla(330, 100%, 12.5%, 1.0)", "rgb(64, 0, 32)", +"hsla(0, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(30, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(60, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(90, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(120, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(150, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(180, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(210, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(240, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(270, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(300, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(330, 0%, 25%, 1.0)", "rgb(64, 64, 64)", +"hsla(0, 12.5%, 25%, 1.0)", "rgb(72, 56, 56)", +"hsla(30, 12.5%, 25%, 1.0)", "rgb(72, 64, 56)", +"hsla(60, 12.5%, 25%, 1.0)", "rgb(72, 72, 56)", +"hsla(90, 12.5%, 25%, 1.0)", "rgb(64, 72, 56)", +"hsla(120, 12.5%, 25%, 1.0)", "rgb(56, 72, 56)", +"hsla(150, 12.5%, 25%, 1.0)", "rgb(56, 72, 64)", +"hsla(180, 12.5%, 25%, 1.0)", "rgb(56, 72, 72)", +"hsla(210, 12.5%, 25%, 1.0)", "rgb(56, 64, 72)", +"hsla(240, 12.5%, 25%, 1.0)", "rgb(56, 56, 72)", +"hsla(270, 12.5%, 25%, 1.0)", "rgb(64, 56, 72)", +"hsla(300, 12.5%, 25%, 1.0)", "rgb(72, 56, 72)", +"hsla(330, 12.5%, 25%, 1.0)", "rgb(72, 56, 64)", +"hsla(0, 25%, 25%, 1.0)", "rgb(80, 48, 48)", +"hsla(30, 25%, 25%, 1.0)", "rgb(80, 64, 48)", +"hsla(60, 25%, 25%, 1.0)", "rgb(80, 80, 48)", +"hsla(90, 25%, 25%, 1.0)", "rgb(64, 80, 48)", +"hsla(120, 25%, 25%, 1.0)", "rgb(48, 80, 48)", +"hsla(150, 25%, 25%, 1.0)", "rgb(48, 80, 64)", +"hsla(180, 25%, 25%, 1.0)", "rgb(48, 80, 80)", +"hsla(210, 25%, 25%, 1.0)", "rgb(48, 64, 80)", +"hsla(240, 25%, 25%, 1.0)", "rgb(48, 48, 80)", +"hsla(270, 25%, 25%, 1.0)", "rgb(64, 48, 80)", +"hsla(300, 25%, 25%, 1.0)", "rgb(80, 48, 80)", +"hsla(330, 25%, 25%, 1.0)", "rgb(80, 48, 64)", +"hsla(0, 37.5%, 25%, 1.0)", "rgb(88, 40, 40)", +"hsla(30, 37.5%, 25%, 1.0)", "rgb(88, 64, 40)", +"hsla(60, 37.5%, 25%, 1.0)", "rgb(88, 88, 40)", +"hsla(90, 37.5%, 25%, 1.0)", "rgb(64, 88, 40)", +"hsla(120, 37.5%, 25%, 1.0)", "rgb(40, 88, 40)", +"hsla(150, 37.5%, 25%, 1.0)", "rgb(40, 88, 64)", +"hsla(180, 37.5%, 25%, 1.0)", "rgb(40, 88, 88)", +"hsla(210, 37.5%, 25%, 1.0)", "rgb(40, 64, 88)", +"hsla(240, 37.5%, 25%, 1.0)", "rgb(40, 40, 88)", +"hsla(270, 37.5%, 25%, 1.0)", "rgb(64, 40, 88)", +"hsla(300, 37.5%, 25%, 1.0)", "rgb(88, 40, 88)", +"hsla(330, 37.5%, 25%, 1.0)", "rgb(88, 40, 64)", +"hsla(0, 50%, 25%, 1.0)", "rgb(96, 32, 32)", +"hsla(30, 50%, 25%, 1.0)", "rgb(96, 64, 32)", +"hsla(60, 50%, 25%, 1.0)", "rgb(96, 96, 32)", +"hsla(90, 50%, 25%, 1.0)", "rgb(64, 96, 32)", +"hsla(120, 50%, 25%, 1.0)", "rgb(32, 96, 32)", +"hsla(150, 50%, 25%, 1.0)", "rgb(32, 96, 64)", +"hsla(180, 50%, 25%, 1.0)", "rgb(32, 96, 96)", +"hsla(210, 50%, 25%, 1.0)", "rgb(32, 64, 96)", +"hsla(240, 50%, 25%, 1.0)", "rgb(32, 32, 96)", +"hsla(270, 50%, 25%, 1.0)", "rgb(64, 32, 96)", +"hsla(300, 50%, 25%, 1.0)", "rgb(96, 32, 96)", +"hsla(330, 50%, 25%, 1.0)", "rgb(96, 32, 64)", +"hsla(0, 62.5%, 25%, 1.0)", "rgb(104, 24, 24)", +"hsla(30, 62.5%, 25%, 1.0)", "rgb(104, 64, 24)", +"hsla(60, 62.5%, 25%, 1.0)", "rgb(104, 104, 24)", +"hsla(90, 62.5%, 25%, 1.0)", "rgb(64, 104, 24)", +"hsla(120, 62.5%, 25%, 1.0)", "rgb(24, 104, 24)", +"hsla(150, 62.5%, 25%, 1.0)", "rgb(24, 104, 64)", +"hsla(180, 62.5%, 25%, 1.0)", "rgb(24, 104, 104)", +"hsla(210, 62.5%, 25%, 1.0)", "rgb(24, 64, 104)", +"hsla(240, 62.5%, 25%, 1.0)", "rgb(24, 24, 104)", +"hsla(270, 62.5%, 25%, 1.0)", "rgb(64, 24, 104)", +"hsla(300, 62.5%, 25%, 1.0)", "rgb(104, 24, 104)", +"hsla(330, 62.5%, 25%, 1.0)", "rgb(104, 24, 64)", +"hsla(0, 75%, 25%, 1.0)", "rgb(112, 16, 16)", +"hsla(30, 75%, 25%, 1.0)", "rgb(112, 64, 16)", +"hsla(60, 75%, 25%, 1.0)", "rgb(112, 112, 16)", +"hsla(90, 75%, 25%, 1.0)", "rgb(64, 112, 16)", +"hsla(120, 75%, 25%, 1.0)", "rgb(16, 112, 16)", +"hsla(150, 75%, 25%, 1.0)", "rgb(16, 112, 64)", +"hsla(180, 75%, 25%, 1.0)", "rgb(16, 112, 112)", +"hsla(210, 75%, 25%, 1.0)", "rgb(16, 64, 112)", +"hsla(240, 75%, 25%, 1.0)", "rgb(16, 16, 112)", +"hsla(270, 75%, 25%, 1.0)", "rgb(64, 16, 112)", +"hsla(300, 75%, 25%, 1.0)", "rgb(112, 16, 112)", +"hsla(330, 75%, 25%, 1.0)", "rgb(112, 16, 64)", +"hsla(0, 87.5%, 25%, 1.0)", "rgb(120, 8, 8)", +"hsla(30, 87.5%, 25%, 1.0)", "rgb(120, 64, 8)", +"hsla(60, 87.5%, 25%, 1.0)", "rgb(120, 120, 8)", +"hsla(90, 87.5%, 25%, 1.0)", "rgb(64, 120, 8)", +"hsla(120, 87.5%, 25%, 1.0)", "rgb(8, 120, 8)", +"hsla(150, 87.5%, 25%, 1.0)", "rgb(8, 120, 64)", +"hsla(180, 87.5%, 25%, 1.0)", "rgb(8, 120, 120)", +"hsla(210, 87.5%, 25%, 1.0)", "rgb(8, 64, 120)", +"hsla(240, 87.5%, 25%, 1.0)", "rgb(8, 8, 120)", +"hsla(270, 87.5%, 25%, 1.0)", "rgb(64, 8, 120)", +"hsla(300, 87.5%, 25%, 1.0)", "rgb(120, 8, 120)", +"hsla(330, 87.5%, 25%, 1.0)", "rgb(120, 8, 64)", +"hsla(0, 100%, 25%, 1.0)", "rgb(128, 0, 0)", +"hsla(30, 100%, 25%, 1.0)", "rgb(128, 64, 0)", +"hsla(60, 100%, 25%, 1.0)", "rgb(128, 128, 0)", +"hsla(90, 100%, 25%, 1.0)", "rgb(64, 128, 0)", +"hsla(120, 100%, 25%, 1.0)", "rgb(0, 128, 0)", +"hsla(150, 100%, 25%, 1.0)", "rgb(0, 128, 64)", +"hsla(180, 100%, 25%, 1.0)", "rgb(0, 128, 128)", +"hsla(210, 100%, 25%, 1.0)", "rgb(0, 64, 128)", +"hsla(240, 100%, 25%, 1.0)", "rgb(0, 0, 128)", +"hsla(270, 100%, 25%, 1.0)", "rgb(64, 0, 128)", +"hsla(300, 100%, 25%, 1.0)", "rgb(128, 0, 128)", +"hsla(330, 100%, 25%, 1.0)", "rgb(128, 0, 64)", +"hsla(0, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(30, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(60, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(90, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(120, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(150, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(180, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(210, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(240, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(270, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(300, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(330, 0%, 37.5%, 1.0)", "rgb(96, 96, 96)", +"hsla(0, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 84)", +"hsla(30, 12.5%, 37.5%, 1.0)", "rgb(108, 96, 84)", +"hsla(60, 12.5%, 37.5%, 1.0)", "rgb(108, 108, 84)", +"hsla(90, 12.5%, 37.5%, 1.0)", "rgb(96, 108, 84)", +"hsla(120, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 84)", +"hsla(150, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 96)", +"hsla(180, 12.5%, 37.5%, 1.0)", "rgb(84, 108, 108)", +"hsla(210, 12.5%, 37.5%, 1.0)", "rgb(84, 96, 108)", +"hsla(240, 12.5%, 37.5%, 1.0)", "rgb(84, 84, 108)", +"hsla(270, 12.5%, 37.5%, 1.0)", "rgb(96, 84, 108)", +"hsla(300, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 108)", +"hsla(330, 12.5%, 37.5%, 1.0)", "rgb(108, 84, 96)", +"hsla(0, 25%, 37.5%, 1.0)", "rgb(120, 72, 72)", +"hsla(30, 25%, 37.5%, 1.0)", "rgb(120, 96, 72)", +"hsla(60, 25%, 37.5%, 1.0)", "rgb(120, 120, 72)", +"hsla(90, 25%, 37.5%, 1.0)", "rgb(96, 120, 72)", +"hsla(120, 25%, 37.5%, 1.0)", "rgb(72, 120, 72)", +"hsla(150, 25%, 37.5%, 1.0)", "rgb(72, 120, 96)", +"hsla(180, 25%, 37.5%, 1.0)", "rgb(72, 120, 120)", +"hsla(210, 25%, 37.5%, 1.0)", "rgb(72, 96, 120)", +"hsla(240, 25%, 37.5%, 1.0)", "rgb(72, 72, 120)", +"hsla(270, 25%, 37.5%, 1.0)", "rgb(96, 72, 120)", +"hsla(300, 25%, 37.5%, 1.0)", "rgb(120, 72, 120)", +"hsla(330, 25%, 37.5%, 1.0)", "rgb(120, 72, 96)", +"hsla(0, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 60)", +"hsla(30, 37.5%, 37.5%, 1.0)", "rgb(131, 96, 60)", +"hsla(60, 37.5%, 37.5%, 1.0)", "rgb(131, 131, 60)", +"hsla(90, 37.5%, 37.5%, 1.0)", "rgb(96, 131, 60)", +"hsla(120, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 60)", +"hsla(150, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 96)", +"hsla(180, 37.5%, 37.5%, 1.0)", "rgb(60, 131, 131)", +"hsla(210, 37.5%, 37.5%, 1.0)", "rgb(60, 96, 131)", +"hsla(240, 37.5%, 37.5%, 1.0)", "rgb(60, 60, 131)", +"hsla(270, 37.5%, 37.5%, 1.0)", "rgb(96, 60, 131)", +"hsla(300, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 131)", +"hsla(330, 37.5%, 37.5%, 1.0)", "rgb(131, 60, 96)", +"hsla(0, 50%, 37.5%, 1.0)", "rgb(143, 48, 48)", +"hsla(30, 50%, 37.5%, 1.0)", "rgb(143, 96, 48)", +"hsla(60, 50%, 37.5%, 1.0)", "rgb(143, 143, 48)", +"hsla(90, 50%, 37.5%, 1.0)", "rgb(96, 143, 48)", +"hsla(120, 50%, 37.5%, 1.0)", "rgb(48, 143, 48)", +"hsla(150, 50%, 37.5%, 1.0)", "rgb(48, 143, 96)", +"hsla(180, 50%, 37.5%, 1.0)", "rgb(48, 143, 143)", +"hsla(210, 50%, 37.5%, 1.0)", "rgb(48, 96, 143)", +"hsla(240, 50%, 37.5%, 1.0)", "rgb(48, 48, 143)", +"hsla(270, 50%, 37.5%, 1.0)", "rgb(96, 48, 143)", +"hsla(300, 50%, 37.5%, 1.0)", "rgb(143, 48, 143)", +"hsla(330, 50%, 37.5%, 1.0)", "rgb(143, 48, 96)", +"hsla(0, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 36)", +"hsla(30, 62.5%, 37.5%, 1.0)", "rgb(155, 96, 36)", +"hsla(60, 62.5%, 37.5%, 1.0)", "rgb(155, 155, 36)", +"hsla(90, 62.5%, 37.5%, 1.0)", "rgb(96, 155, 36)", +"hsla(120, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 36)", +"hsla(150, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 96)", +"hsla(180, 62.5%, 37.5%, 1.0)", "rgb(36, 155, 155)", +"hsla(210, 62.5%, 37.5%, 1.0)", "rgb(36, 96, 155)", +"hsla(240, 62.5%, 37.5%, 1.0)", "rgb(36, 36, 155)", +"hsla(270, 62.5%, 37.5%, 1.0)", "rgb(96, 36, 155)", +"hsla(300, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 155)", +"hsla(330, 62.5%, 37.5%, 1.0)", "rgb(155, 36, 96)", +"hsla(0, 75%, 37.5%, 1.0)", "rgb(167, 24, 24)", +"hsla(30, 75%, 37.5%, 1.0)", "rgb(167, 96, 24)", +"hsla(60, 75%, 37.5%, 1.0)", "rgb(167, 167, 24)", +"hsla(90, 75%, 37.5%, 1.0)", "rgb(96, 167, 24)", +"hsla(120, 75%, 37.5%, 1.0)", "rgb(24, 167, 24)", +"hsla(150, 75%, 37.5%, 1.0)", "rgb(24, 167, 96)", +"hsla(180, 75%, 37.5%, 1.0)", "rgb(24, 167, 167)", +"hsla(210, 75%, 37.5%, 1.0)", "rgb(24, 96, 167)", +"hsla(240, 75%, 37.5%, 1.0)", "rgb(24, 24, 167)", +"hsla(270, 75%, 37.5%, 1.0)", "rgb(96, 24, 167)", +"hsla(300, 75%, 37.5%, 1.0)", "rgb(167, 24, 167)", +"hsla(330, 75%, 37.5%, 1.0)", "rgb(167, 24, 96)", +"hsla(0, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 12)", +"hsla(30, 87.5%, 37.5%, 1.0)", "rgb(179, 96, 12)", +"hsla(60, 87.5%, 37.5%, 1.0)", "rgb(179, 179, 12)", +"hsla(90, 87.5%, 37.5%, 1.0)", "rgb(96, 179, 12)", +"hsla(120, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 12)", +"hsla(150, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 96)", +"hsla(180, 87.5%, 37.5%, 1.0)", "rgb(12, 179, 179)", +"hsla(210, 87.5%, 37.5%, 1.0)", "rgb(12, 96, 179)", +"hsla(240, 87.5%, 37.5%, 1.0)", "rgb(12, 12, 179)", +"hsla(270, 87.5%, 37.5%, 1.0)", "rgb(96, 12, 179)", +"hsla(300, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 179)", +"hsla(330, 87.5%, 37.5%, 1.0)", "rgb(179, 12, 96)", +"hsla(0, 100%, 37.5%, 1.0)", "rgb(191, 0, 0)", +"hsla(30, 100%, 37.5%, 1.0)", "rgb(191, 96, 0)", +"hsla(60, 100%, 37.5%, 1.0)", "rgb(191, 191, 0)", +"hsla(90, 100%, 37.5%, 1.0)", "rgb(96, 191, 0)", +"hsla(120, 100%, 37.5%, 1.0)", "rgb(0, 191, 0)", +"hsla(150, 100%, 37.5%, 1.0)", "rgb(0, 191, 96)", +"hsla(180, 100%, 37.5%, 1.0)", "rgb(0, 191, 191)", +"hsla(210, 100%, 37.5%, 1.0)", "rgb(0, 96, 191)", +"hsla(240, 100%, 37.5%, 1.0)", "rgb(0, 0, 191)", +"hsla(270, 100%, 37.5%, 1.0)", "rgb(96, 0, 191)", +"hsla(300, 100%, 37.5%, 1.0)", "rgb(191, 0, 191)", +"hsla(330, 100%, 37.5%, 1.0)", "rgb(191, 0, 96)", +"hsla(0, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(30, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(60, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(90, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(120, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(150, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(180, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(210, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(240, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(270, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(300, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(330, 0%, 50%, 1.0)", "rgb(128, 128, 128)", +"hsla(0, 12.5%, 50%, 1.0)", "rgb(143, 112, 112)", +"hsla(30, 12.5%, 50%, 1.0)", "rgb(143, 128, 112)", +"hsla(60, 12.5%, 50%, 1.0)", "rgb(143, 143, 112)", +"hsla(90, 12.5%, 50%, 1.0)", "rgb(128, 143, 112)", +"hsla(120, 12.5%, 50%, 1.0)", "rgb(112, 143, 112)", +"hsla(150, 12.5%, 50%, 1.0)", "rgb(112, 143, 128)", +"hsla(180, 12.5%, 50%, 1.0)", "rgb(112, 143, 143)", +"hsla(210, 12.5%, 50%, 1.0)", "rgb(112, 128, 143)", +"hsla(240, 12.5%, 50%, 1.0)", "rgb(112, 112, 143)", +"hsla(270, 12.5%, 50%, 1.0)", "rgb(128, 112, 143)", +"hsla(300, 12.5%, 50%, 1.0)", "rgb(143, 112, 143)", +"hsla(330, 12.5%, 50%, 1.0)", "rgb(143, 112, 128)", +"hsla(0, 25%, 50%, 1.0)", "rgb(159, 96, 96)", +"hsla(30, 25%, 50%, 1.0)", "rgb(159, 128, 96)", +"hsla(60, 25%, 50%, 1.0)", "rgb(159, 159, 96)", +"hsla(90, 25%, 50%, 1.0)", "rgb(128, 159, 96)", +"hsla(120, 25%, 50%, 1.0)", "rgb(96, 159, 96)", +"hsla(150, 25%, 50%, 1.0)", "rgb(96, 159, 128)", +"hsla(180, 25%, 50%, 1.0)", "rgb(96, 159, 159)", +"hsla(210, 25%, 50%, 1.0)", "rgb(96, 128, 159)", +"hsla(240, 25%, 50%, 1.0)", "rgb(96, 96, 159)", +"hsla(270, 25%, 50%, 1.0)", "rgb(128, 96, 159)", +"hsla(300, 25%, 50%, 1.0)", "rgb(159, 96, 159)", +"hsla(330, 25%, 50%, 1.0)", "rgb(159, 96, 128)", +"hsla(0, 37.5%, 50%, 1.0)", "rgb(175, 80, 80)", +"hsla(30, 37.5%, 50%, 1.0)", "rgb(175, 128, 80)", +"hsla(60, 37.5%, 50%, 1.0)", "rgb(175, 175, 80)", +"hsla(90, 37.5%, 50%, 1.0)", "rgb(128, 175, 80)", +"hsla(120, 37.5%, 50%, 1.0)", "rgb(80, 175, 80)", +"hsla(150, 37.5%, 50%, 1.0)", "rgb(80, 175, 128)", +"hsla(180, 37.5%, 50%, 1.0)", "rgb(80, 175, 175)", +"hsla(210, 37.5%, 50%, 1.0)", "rgb(80, 128, 175)", +"hsla(240, 37.5%, 50%, 1.0)", "rgb(80, 80, 175)", +"hsla(270, 37.5%, 50%, 1.0)", "rgb(128, 80, 175)", +"hsla(300, 37.5%, 50%, 1.0)", "rgb(175, 80, 175)", +"hsla(330, 37.5%, 50%, 1.0)", "rgb(175, 80, 128)", +"hsla(0, 50%, 50%, 1.0)", "rgb(191, 64, 64)", +"hsla(30, 50%, 50%, 1.0)", "rgb(191, 128, 64)", +"hsla(60, 50%, 50%, 1.0)", "rgb(191, 191, 64)", +"hsla(90, 50%, 50%, 1.0)", "rgb(128, 191, 64)", +"hsla(120, 50%, 50%, 1.0)", "rgb(64, 191, 64)", +"hsla(150, 50%, 50%, 1.0)", "rgb(64, 191, 128)", +"hsla(180, 50%, 50%, 1.0)", "rgb(64, 191, 191)", +"hsla(210, 50%, 50%, 1.0)", "rgb(64, 128, 191)", +"hsla(240, 50%, 50%, 1.0)", "rgb(64, 64, 191)", +"hsla(270, 50%, 50%, 1.0)", "rgb(128, 64, 191)", +"hsla(300, 50%, 50%, 1.0)", "rgb(191, 64, 191)", +"hsla(330, 50%, 50%, 1.0)", "rgb(191, 64, 128)", +"hsla(0, 62.5%, 50%, 1.0)", "rgb(207, 48, 48)", +"hsla(30, 62.5%, 50%, 1.0)", "rgb(207, 128, 48)", +"hsla(60, 62.5%, 50%, 1.0)", "rgb(207, 207, 48)", +"hsla(90, 62.5%, 50%, 1.0)", "rgb(128, 207, 48)", +"hsla(120, 62.5%, 50%, 1.0)", "rgb(48, 207, 48)", +"hsla(150, 62.5%, 50%, 1.0)", "rgb(48, 207, 128)", +"hsla(180, 62.5%, 50%, 1.0)", "rgb(48, 207, 207)", +"hsla(210, 62.5%, 50%, 1.0)", "rgb(48, 128, 207)", +"hsla(240, 62.5%, 50%, 1.0)", "rgb(48, 48, 207)", +"hsla(270, 62.5%, 50%, 1.0)", "rgb(128, 48, 207)", +"hsla(300, 62.5%, 50%, 1.0)", "rgb(207, 48, 207)", +"hsla(330, 62.5%, 50%, 1.0)", "rgb(207, 48, 128)", +"hsla(0, 75%, 50%, 1.0)", "rgb(223, 32, 32)", +"hsla(30, 75%, 50%, 1.0)", "rgb(223, 128, 32)", +"hsla(60, 75%, 50%, 1.0)", "rgb(223, 223, 32)", +"hsla(90, 75%, 50%, 1.0)", "rgb(128, 223, 32)", +"hsla(120, 75%, 50%, 1.0)", "rgb(32, 223, 32)", +"hsla(150, 75%, 50%, 1.0)", "rgb(32, 223, 128)", +"hsla(180, 75%, 50%, 1.0)", "rgb(32, 223, 223)", +"hsla(210, 75%, 50%, 1.0)", "rgb(32, 128, 223)", +"hsla(240, 75%, 50%, 1.0)", "rgb(32, 32, 223)", +"hsla(270, 75%, 50%, 1.0)", "rgb(128, 32, 223)", +"hsla(300, 75%, 50%, 1.0)", "rgb(223, 32, 223)", +"hsla(330, 75%, 50%, 1.0)", "rgb(223, 32, 128)", +"hsla(0, 87.5%, 50%, 1.0)", "rgb(239, 16, 16)", +"hsla(30, 87.5%, 50%, 1.0)", "rgb(239, 128, 16)", +"hsla(60, 87.5%, 50%, 1.0)", "rgb(239, 239, 16)", +"hsla(90, 87.5%, 50%, 1.0)", "rgb(128, 239, 16)", +"hsla(120, 87.5%, 50%, 1.0)", "rgb(16, 239, 16)", +"hsla(150, 87.5%, 50%, 1.0)", "rgb(16, 239, 128)", +"hsla(180, 87.5%, 50%, 1.0)", "rgb(16, 239, 239)", +"hsla(210, 87.5%, 50%, 1.0)", "rgb(16, 128, 239)", +"hsla(240, 87.5%, 50%, 1.0)", "rgb(16, 16, 239)", +"hsla(270, 87.5%, 50%, 1.0)", "rgb(128, 16, 239)", +"hsla(300, 87.5%, 50%, 1.0)", "rgb(239, 16, 239)", +"hsla(330, 87.5%, 50%, 1.0)", "rgb(239, 16, 128)", +"hsla(0, 100%, 50%, 1.0)", "rgb(255, 0, 0)", +"hsla(30, 100%, 50%, 1.0)", "rgb(255, 128, 0)", +"hsla(60, 100%, 50%, 1.0)", "rgb(255, 255, 0)", +"hsla(90, 100%, 50%, 1.0)", "rgb(128, 255, 0)", +"hsla(120, 100%, 50%, 1.0)", "rgb(0, 255, 0)", +"hsla(150, 100%, 50%, 1.0)", "rgb(0, 255, 128)", +"hsla(180, 100%, 50%, 1.0)", "rgb(0, 255, 255)", +"hsla(210, 100%, 50%, 1.0)", "rgb(0, 128, 255)", +"hsla(240, 100%, 50%, 1.0)", "rgb(0, 0, 255)", +"hsla(270, 100%, 50%, 1.0)", "rgb(128, 0, 255)", +"hsla(300, 100%, 50%, 1.0)", "rgb(255, 0, 255)", +"hsla(330, 100%, 50%, 1.0)", "rgb(255, 0, 128)", +"hsla(0, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(30, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(60, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(90, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(120, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(150, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(180, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(210, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(240, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(270, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(300, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(330, 0%, 62.5%, 1.0)", "rgb(159, 159, 159)", +"hsla(0, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 147)", +"hsla(30, 12.5%, 62.5%, 1.0)", "rgb(171, 159, 147)", +"hsla(60, 12.5%, 62.5%, 1.0)", "rgb(171, 171, 147)", +"hsla(90, 12.5%, 62.5%, 1.0)", "rgb(159, 171, 147)", +"hsla(120, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 147)", +"hsla(150, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 159)", +"hsla(180, 12.5%, 62.5%, 1.0)", "rgb(147, 171, 171)", +"hsla(210, 12.5%, 62.5%, 1.0)", "rgb(147, 159, 171)", +"hsla(240, 12.5%, 62.5%, 1.0)", "rgb(147, 147, 171)", +"hsla(270, 12.5%, 62.5%, 1.0)", "rgb(159, 147, 171)", +"hsla(300, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 171)", +"hsla(330, 12.5%, 62.5%, 1.0)", "rgb(171, 147, 159)", +"hsla(0, 25%, 62.5%, 1.0)", "rgb(183, 135, 135)", +"hsla(30, 25%, 62.5%, 1.0)", "rgb(183, 159, 135)", +"hsla(60, 25%, 62.5%, 1.0)", "rgb(183, 183, 135)", +"hsla(90, 25%, 62.5%, 1.0)", "rgb(159, 183, 135)", +"hsla(120, 25%, 62.5%, 1.0)", "rgb(135, 183, 135)", +"hsla(150, 25%, 62.5%, 1.0)", "rgb(135, 183, 159)", +"hsla(180, 25%, 62.5%, 1.0)", "rgb(135, 183, 183)", +"hsla(210, 25%, 62.5%, 1.0)", "rgb(135, 159, 183)", +"hsla(240, 25%, 62.5%, 1.0)", "rgb(135, 135, 183)", +"hsla(270, 25%, 62.5%, 1.0)", "rgb(159, 135, 183)", +"hsla(300, 25%, 62.5%, 1.0)", "rgb(183, 135, 183)", +"hsla(330, 25%, 62.5%, 1.0)", "rgb(183, 135, 159)", +"hsla(0, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 124)", +"hsla(30, 37.5%, 62.5%, 1.0)", "rgb(195, 159, 124)", +"hsla(60, 37.5%, 62.5%, 1.0)", "rgb(195, 195, 124)", +"hsla(90, 37.5%, 62.5%, 1.0)", "rgb(159, 195, 124)", +"hsla(120, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 124)", +"hsla(150, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 159)", +"hsla(180, 37.5%, 62.5%, 1.0)", "rgb(124, 195, 195)", +"hsla(210, 37.5%, 62.5%, 1.0)", "rgb(124, 159, 195)", +"hsla(240, 37.5%, 62.5%, 1.0)", "rgb(124, 124, 195)", +"hsla(270, 37.5%, 62.5%, 1.0)", "rgb(159, 124, 195)", +"hsla(300, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 195)", +"hsla(330, 37.5%, 62.5%, 1.0)", "rgb(195, 124, 159)", +"hsla(0, 50%, 62.5%, 1.0)", "rgb(207, 112, 112)", +"hsla(30, 50%, 62.5%, 1.0)", "rgb(207, 159, 112)", +"hsla(60, 50%, 62.5%, 1.0)", "rgb(207, 207, 112)", +"hsla(90, 50%, 62.5%, 1.0)", "rgb(159, 207, 112)", +"hsla(120, 50%, 62.5%, 1.0)", "rgb(112, 207, 112)", +"hsla(150, 50%, 62.5%, 1.0)", "rgb(112, 207, 159)", +"hsla(180, 50%, 62.5%, 1.0)", "rgb(112, 207, 207)", +"hsla(210, 50%, 62.5%, 1.0)", "rgb(112, 159, 207)", +"hsla(240, 50%, 62.5%, 1.0)", "rgb(112, 112, 207)", +"hsla(270, 50%, 62.5%, 1.0)", "rgb(159, 112, 207)", +"hsla(300, 50%, 62.5%, 1.0)", "rgb(207, 112, 207)", +"hsla(330, 50%, 62.5%, 1.0)", "rgb(207, 112, 159)", +"hsla(0, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 100)", +"hsla(30, 62.5%, 62.5%, 1.0)", "rgb(219, 159, 100)", +"hsla(60, 62.5%, 62.5%, 1.0)", "rgb(219, 219, 100)", +"hsla(90, 62.5%, 62.5%, 1.0)", "rgb(159, 219, 100)", +"hsla(120, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 100)", +"hsla(150, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 159)", +"hsla(180, 62.5%, 62.5%, 1.0)", "rgb(100, 219, 219)", +"hsla(210, 62.5%, 62.5%, 1.0)", "rgb(100, 159, 219)", +"hsla(240, 62.5%, 62.5%, 1.0)", "rgb(100, 100, 219)", +"hsla(270, 62.5%, 62.5%, 1.0)", "rgb(159, 100, 219)", +"hsla(300, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 219)", +"hsla(330, 62.5%, 62.5%, 1.0)", "rgb(219, 100, 159)", +"hsla(0, 75%, 62.5%, 1.0)", "rgb(231, 88, 88)", +"hsla(30, 75%, 62.5%, 1.0)", "rgb(231, 159, 88)", +"hsla(60, 75%, 62.5%, 1.0)", "rgb(231, 231, 88)", +"hsla(90, 75%, 62.5%, 1.0)", "rgb(159, 231, 88)", +"hsla(120, 75%, 62.5%, 1.0)", "rgb(88, 231, 88)", +"hsla(150, 75%, 62.5%, 1.0)", "rgb(88, 231, 159)", +"hsla(180, 75%, 62.5%, 1.0)", "rgb(88, 231, 231)", +"hsla(210, 75%, 62.5%, 1.0)", "rgb(88, 159, 231)", +"hsla(240, 75%, 62.5%, 1.0)", "rgb(88, 88, 231)", +"hsla(270, 75%, 62.5%, 1.0)", "rgb(159, 88, 231)", +"hsla(300, 75%, 62.5%, 1.0)", "rgb(231, 88, 231)", +"hsla(330, 75%, 62.5%, 1.0)", "rgb(231, 88, 159)", +"hsla(0, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 76)", +"hsla(30, 87.5%, 62.5%, 1.0)", "rgb(243, 159, 76)", +"hsla(60, 87.5%, 62.5%, 1.0)", "rgb(243, 243, 76)", +"hsla(90, 87.5%, 62.5%, 1.0)", "rgb(159, 243, 76)", +"hsla(120, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 76)", +"hsla(150, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 159)", +"hsla(180, 87.5%, 62.5%, 1.0)", "rgb(76, 243, 243)", +"hsla(210, 87.5%, 62.5%, 1.0)", "rgb(76, 159, 243)", +"hsla(240, 87.5%, 62.5%, 1.0)", "rgb(76, 76, 243)", +"hsla(270, 87.5%, 62.5%, 1.0)", "rgb(159, 76, 243)", +"hsla(300, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 243)", +"hsla(330, 87.5%, 62.5%, 1.0)", "rgb(243, 76, 159)", +"hsla(0, 100%, 62.5%, 1.0)", "rgb(255, 64, 64)", +"hsla(30, 100%, 62.5%, 1.0)", "rgb(255, 159, 64)", +"hsla(60, 100%, 62.5%, 1.0)", "rgb(255, 255, 64)", +"hsla(90, 100%, 62.5%, 1.0)", "rgb(159, 255, 64)", +"hsla(120, 100%, 62.5%, 1.0)", "rgb(64, 255, 64)", +"hsla(150, 100%, 62.5%, 1.0)", "rgb(64, 255, 159)", +"hsla(180, 100%, 62.5%, 1.0)", "rgb(64, 255, 255)", +"hsla(210, 100%, 62.5%, 1.0)", "rgb(64, 159, 255)", +"hsla(240, 100%, 62.5%, 1.0)", "rgb(64, 64, 255)", +"hsla(270, 100%, 62.5%, 1.0)", "rgb(159, 64, 255)", +"hsla(300, 100%, 62.5%, 1.0)", "rgb(255, 64, 255)", +"hsla(330, 100%, 62.5%, 1.0)", "rgb(255, 64, 159)", +"hsla(0, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(30, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(60, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(90, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(120, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(150, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(180, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(210, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(240, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(270, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(300, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(330, 0%, 75%, 1.0)", "rgb(191, 191, 191)", +"hsla(0, 12.5%, 75%, 1.0)", "rgb(199, 183, 183)", +"hsla(30, 12.5%, 75%, 1.0)", "rgb(199, 191, 183)", +"hsla(60, 12.5%, 75%, 1.0)", "rgb(199, 199, 183)", +"hsla(90, 12.5%, 75%, 1.0)", "rgb(191, 199, 183)", +"hsla(120, 12.5%, 75%, 1.0)", "rgb(183, 199, 183)", +"hsla(150, 12.5%, 75%, 1.0)", "rgb(183, 199, 191)", +"hsla(180, 12.5%, 75%, 1.0)", "rgb(183, 199, 199)", +"hsla(210, 12.5%, 75%, 1.0)", "rgb(183, 191, 199)", +"hsla(240, 12.5%, 75%, 1.0)", "rgb(183, 183, 199)", +"hsla(270, 12.5%, 75%, 1.0)", "rgb(191, 183, 199)", +"hsla(300, 12.5%, 75%, 1.0)", "rgb(199, 183, 199)", +"hsla(330, 12.5%, 75%, 1.0)", "rgb(199, 183, 191)", +"hsla(0, 25%, 75%, 1.0)", "rgb(207, 175, 175)", +"hsla(30, 25%, 75%, 1.0)", "rgb(207, 191, 175)", +"hsla(60, 25%, 75%, 1.0)", "rgb(207, 207, 175)", +"hsla(90, 25%, 75%, 1.0)", "rgb(191, 207, 175)", +"hsla(120, 25%, 75%, 1.0)", "rgb(175, 207, 175)", +"hsla(150, 25%, 75%, 1.0)", "rgb(175, 207, 191)", +"hsla(180, 25%, 75%, 1.0)", "rgb(175, 207, 207)", +"hsla(210, 25%, 75%, 1.0)", "rgb(175, 191, 207)", +"hsla(240, 25%, 75%, 1.0)", "rgb(175, 175, 207)", +"hsla(270, 25%, 75%, 1.0)", "rgb(191, 175, 207)", +"hsla(300, 25%, 75%, 1.0)", "rgb(207, 175, 207)", +"hsla(330, 25%, 75%, 1.0)", "rgb(207, 175, 191)", +"hsla(0, 37.5%, 75%, 1.0)", "rgb(215, 167, 167)", +"hsla(30, 37.5%, 75%, 1.0)", "rgb(215, 191, 167)", +"hsla(60, 37.5%, 75%, 1.0)", "rgb(215, 215, 167)", +"hsla(90, 37.5%, 75%, 1.0)", "rgb(191, 215, 167)", +"hsla(120, 37.5%, 75%, 1.0)", "rgb(167, 215, 167)", +"hsla(150, 37.5%, 75%, 1.0)", "rgb(167, 215, 191)", +"hsla(180, 37.5%, 75%, 1.0)", "rgb(167, 215, 215)", +"hsla(210, 37.5%, 75%, 1.0)", "rgb(167, 191, 215)", +"hsla(240, 37.5%, 75%, 1.0)", "rgb(167, 167, 215)", +"hsla(270, 37.5%, 75%, 1.0)", "rgb(191, 167, 215)", +"hsla(300, 37.5%, 75%, 1.0)", "rgb(215, 167, 215)", +"hsla(330, 37.5%, 75%, 1.0)", "rgb(215, 167, 191)", +"hsla(0, 50%, 75%, 1.0)", "rgb(223, 159, 159)", +"hsla(30, 50%, 75%, 1.0)", "rgb(223, 191, 159)", +"hsla(60, 50%, 75%, 1.0)", "rgb(223, 223, 159)", +"hsla(90, 50%, 75%, 1.0)", "rgb(191, 223, 159)", +"hsla(120, 50%, 75%, 1.0)", "rgb(159, 223, 159)", +"hsla(150, 50%, 75%, 1.0)", "rgb(159, 223, 191)", +"hsla(180, 50%, 75%, 1.0)", "rgb(159, 223, 223)", +"hsla(210, 50%, 75%, 1.0)", "rgb(159, 191, 223)", +"hsla(240, 50%, 75%, 1.0)", "rgb(159, 159, 223)", +"hsla(270, 50%, 75%, 1.0)", "rgb(191, 159, 223)", +"hsla(300, 50%, 75%, 1.0)", "rgb(223, 159, 223)", +"hsla(330, 50%, 75%, 1.0)", "rgb(223, 159, 191)", +"hsla(0, 62.5%, 75%, 1.0)", "rgb(231, 151, 151)", +"hsla(30, 62.5%, 75%, 1.0)", "rgb(231, 191, 151)", +"hsla(60, 62.5%, 75%, 1.0)", "rgb(231, 231, 151)", +"hsla(90, 62.5%, 75%, 1.0)", "rgb(191, 231, 151)", +"hsla(120, 62.5%, 75%, 1.0)", "rgb(151, 231, 151)", +"hsla(150, 62.5%, 75%, 1.0)", "rgb(151, 231, 191)", +"hsla(180, 62.5%, 75%, 1.0)", "rgb(151, 231, 231)", +"hsla(210, 62.5%, 75%, 1.0)", "rgb(151, 191, 231)", +"hsla(240, 62.5%, 75%, 1.0)", "rgb(151, 151, 231)", +"hsla(270, 62.5%, 75%, 1.0)", "rgb(191, 151, 231)", +"hsla(300, 62.5%, 75%, 1.0)", "rgb(231, 151, 231)", +"hsla(330, 62.5%, 75%, 1.0)", "rgb(231, 151, 191)", +"hsla(0, 75%, 75%, 1.0)", "rgb(239, 143, 143)", +"hsla(30, 75%, 75%, 1.0)", "rgb(239, 191, 143)", +"hsla(60, 75%, 75%, 1.0)", "rgb(239, 239, 143)", +"hsla(90, 75%, 75%, 1.0)", "rgb(191, 239, 143)", +"hsla(120, 75%, 75%, 1.0)", "rgb(143, 239, 143)", +"hsla(150, 75%, 75%, 1.0)", "rgb(143, 239, 191)", +"hsla(180, 75%, 75%, 1.0)", "rgb(143, 239, 239)", +"hsla(210, 75%, 75%, 1.0)", "rgb(143, 191, 239)", +"hsla(240, 75%, 75%, 1.0)", "rgb(143, 143, 239)", +"hsla(270, 75%, 75%, 1.0)", "rgb(191, 143, 239)", +"hsla(300, 75%, 75%, 1.0)", "rgb(239, 143, 239)", +"hsla(330, 75%, 75%, 1.0)", "rgb(239, 143, 191)", +"hsla(0, 87.5%, 75%, 1.0)", "rgb(247, 135, 135)", +"hsla(30, 87.5%, 75%, 1.0)", "rgb(247, 191, 135)", +"hsla(60, 87.5%, 75%, 1.0)", "rgb(247, 247, 135)", +"hsla(90, 87.5%, 75%, 1.0)", "rgb(191, 247, 135)", +"hsla(120, 87.5%, 75%, 1.0)", "rgb(135, 247, 135)", +"hsla(150, 87.5%, 75%, 1.0)", "rgb(135, 247, 191)", +"hsla(180, 87.5%, 75%, 1.0)", "rgb(135, 247, 247)", +"hsla(210, 87.5%, 75%, 1.0)", "rgb(135, 191, 247)", +"hsla(240, 87.5%, 75%, 1.0)", "rgb(135, 135, 247)", +"hsla(270, 87.5%, 75%, 1.0)", "rgb(191, 135, 247)", +"hsla(300, 87.5%, 75%, 1.0)", "rgb(247, 135, 247)", +"hsla(330, 87.5%, 75%, 1.0)", "rgb(247, 135, 191)", +"hsla(0, 100%, 75%, 1.0)", "rgb(255, 128, 128)", +"hsla(30, 100%, 75%, 1.0)", "rgb(255, 191, 128)", +"hsla(60, 100%, 75%, 1.0)", "rgb(255, 255, 128)", +"hsla(90, 100%, 75%, 1.0)", "rgb(191, 255, 128)", +"hsla(120, 100%, 75%, 1.0)", "rgb(128, 255, 128)", +"hsla(150, 100%, 75%, 1.0)", "rgb(128, 255, 191)", +"hsla(180, 100%, 75%, 1.0)", "rgb(128, 255, 255)", +"hsla(210, 100%, 75%, 1.0)", "rgb(128, 191, 255)", +"hsla(240, 100%, 75%, 1.0)", "rgb(128, 128, 255)", +"hsla(270, 100%, 75%, 1.0)", "rgb(191, 128, 255)", +"hsla(300, 100%, 75%, 1.0)", "rgb(255, 128, 255)", +"hsla(330, 100%, 75%, 1.0)", "rgb(255, 128, 191)", +"hsla(0, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(30, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(60, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(90, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(120, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(150, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(180, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(210, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(240, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(270, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(300, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(330, 0%, 87.5%, 1.0)", "rgb(223, 223, 223)", +"hsla(0, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 219)", +"hsla(30, 12.5%, 87.5%, 1.0)", "rgb(227, 223, 219)", +"hsla(60, 12.5%, 87.5%, 1.0)", "rgb(227, 227, 219)", +"hsla(90, 12.5%, 87.5%, 1.0)", "rgb(223, 227, 219)", +"hsla(120, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 219)", +"hsla(150, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 223)", +"hsla(180, 12.5%, 87.5%, 1.0)", "rgb(219, 227, 227)", +"hsla(210, 12.5%, 87.5%, 1.0)", "rgb(219, 223, 227)", +"hsla(240, 12.5%, 87.5%, 1.0)", "rgb(219, 219, 227)", +"hsla(270, 12.5%, 87.5%, 1.0)", "rgb(223, 219, 227)", +"hsla(300, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 227)", +"hsla(330, 12.5%, 87.5%, 1.0)", "rgb(227, 219, 223)", +"hsla(0, 25%, 87.5%, 1.0)", "rgb(231, 215, 215)", +"hsla(30, 25%, 87.5%, 1.0)", "rgb(231, 223, 215)", +"hsla(60, 25%, 87.5%, 1.0)", "rgb(231, 231, 215)", +"hsla(90, 25%, 87.5%, 1.0)", "rgb(223, 231, 215)", +"hsla(120, 25%, 87.5%, 1.0)", "rgb(215, 231, 215)", +"hsla(150, 25%, 87.5%, 1.0)", "rgb(215, 231, 223)", +"hsla(180, 25%, 87.5%, 1.0)", "rgb(215, 231, 231)", +"hsla(210, 25%, 87.5%, 1.0)", "rgb(215, 223, 231)", +"hsla(240, 25%, 87.5%, 1.0)", "rgb(215, 215, 231)", +"hsla(270, 25%, 87.5%, 1.0)", "rgb(223, 215, 231)", +"hsla(300, 25%, 87.5%, 1.0)", "rgb(231, 215, 231)", +"hsla(330, 25%, 87.5%, 1.0)", "rgb(231, 215, 223)", +"hsla(0, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 211)", +"hsla(30, 37.5%, 87.5%, 1.0)", "rgb(235, 223, 211)", +"hsla(60, 37.5%, 87.5%, 1.0)", "rgb(235, 235, 211)", +"hsla(90, 37.5%, 87.5%, 1.0)", "rgb(223, 235, 211)", +"hsla(120, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 211)", +"hsla(150, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 223)", +"hsla(180, 37.5%, 87.5%, 1.0)", "rgb(211, 235, 235)", +"hsla(210, 37.5%, 87.5%, 1.0)", "rgb(211, 223, 235)", +"hsla(240, 37.5%, 87.5%, 1.0)", "rgb(211, 211, 235)", +"hsla(270, 37.5%, 87.5%, 1.0)", "rgb(223, 211, 235)", +"hsla(300, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 235)", +"hsla(330, 37.5%, 87.5%, 1.0)", "rgb(235, 211, 223)", +"hsla(0, 50%, 87.5%, 1.0)", "rgb(239, 207, 207)", +"hsla(30, 50%, 87.5%, 1.0)", "rgb(239, 223, 207)", +"hsla(60, 50%, 87.5%, 1.0)", "rgb(239, 239, 207)", +"hsla(90, 50%, 87.5%, 1.0)", "rgb(223, 239, 207)", +"hsla(120, 50%, 87.5%, 1.0)", "rgb(207, 239, 207)", +"hsla(150, 50%, 87.5%, 1.0)", "rgb(207, 239, 223)", +"hsla(180, 50%, 87.5%, 1.0)", "rgb(207, 239, 239)", +"hsla(210, 50%, 87.5%, 1.0)", "rgb(207, 223, 239)", +"hsla(240, 50%, 87.5%, 1.0)", "rgb(207, 207, 239)", +"hsla(270, 50%, 87.5%, 1.0)", "rgb(223, 207, 239)", +"hsla(300, 50%, 87.5%, 1.0)", "rgb(239, 207, 239)", +"hsla(330, 50%, 87.5%, 1.0)", "rgb(239, 207, 223)", +"hsla(0, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 203)", +"hsla(30, 62.5%, 87.5%, 1.0)", "rgb(243, 223, 203)", +"hsla(60, 62.5%, 87.5%, 1.0)", "rgb(243, 243, 203)", +"hsla(90, 62.5%, 87.5%, 1.0)", "rgb(223, 243, 203)", +"hsla(120, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 203)", +"hsla(150, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 223)", +"hsla(180, 62.5%, 87.5%, 1.0)", "rgb(203, 243, 243)", +"hsla(210, 62.5%, 87.5%, 1.0)", "rgb(203, 223, 243)", +"hsla(240, 62.5%, 87.5%, 1.0)", "rgb(203, 203, 243)", +"hsla(270, 62.5%, 87.5%, 1.0)", "rgb(223, 203, 243)", +"hsla(300, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 243)", +"hsla(330, 62.5%, 87.5%, 1.0)", "rgb(243, 203, 223)", +"hsla(0, 75%, 87.5%, 1.0)", "rgb(247, 199, 199)", +"hsla(30, 75%, 87.5%, 1.0)", "rgb(247, 223, 199)", +"hsla(60, 75%, 87.5%, 1.0)", "rgb(247, 247, 199)", +"hsla(90, 75%, 87.5%, 1.0)", "rgb(223, 247, 199)", +"hsla(120, 75%, 87.5%, 1.0)", "rgb(199, 247, 199)", +"hsla(150, 75%, 87.5%, 1.0)", "rgb(199, 247, 223)", +"hsla(180, 75%, 87.5%, 1.0)", "rgb(199, 247, 247)", +"hsla(210, 75%, 87.5%, 1.0)", "rgb(199, 223, 247)", +"hsla(240, 75%, 87.5%, 1.0)", "rgb(199, 199, 247)", +"hsla(270, 75%, 87.5%, 1.0)", "rgb(223, 199, 247)", +"hsla(300, 75%, 87.5%, 1.0)", "rgb(247, 199, 247)", +"hsla(330, 75%, 87.5%, 1.0)", "rgb(247, 199, 223)", +"hsla(0, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 195)", +"hsla(30, 87.5%, 87.5%, 1.0)", "rgb(251, 223, 195)", +"hsla(60, 87.5%, 87.5%, 1.0)", "rgb(251, 251, 195)", +"hsla(90, 87.5%, 87.5%, 1.0)", "rgb(223, 251, 195)", +"hsla(120, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 195)", +"hsla(150, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 223)", +"hsla(180, 87.5%, 87.5%, 1.0)", "rgb(195, 251, 251)", +"hsla(210, 87.5%, 87.5%, 1.0)", "rgb(195, 223, 251)", +"hsla(240, 87.5%, 87.5%, 1.0)", "rgb(195, 195, 251)", +"hsla(270, 87.5%, 87.5%, 1.0)", "rgb(223, 195, 251)", +"hsla(300, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 251)", +"hsla(330, 87.5%, 87.5%, 1.0)", "rgb(251, 195, 223)", +"hsla(0, 100%, 87.5%, 1.0)", "rgb(255, 191, 191)", +"hsla(30, 100%, 87.5%, 1.0)", "rgb(255, 223, 191)", +"hsla(60, 100%, 87.5%, 1.0)", "rgb(255, 255, 191)", +"hsla(90, 100%, 87.5%, 1.0)", "rgb(223, 255, 191)", +"hsla(120, 100%, 87.5%, 1.0)", "rgb(191, 255, 191)", +"hsla(150, 100%, 87.5%, 1.0)", "rgb(191, 255, 223)", +"hsla(180, 100%, 87.5%, 1.0)", "rgb(191, 255, 255)", +"hsla(210, 100%, 87.5%, 1.0)", "rgb(191, 223, 255)", +"hsla(240, 100%, 87.5%, 1.0)", "rgb(191, 191, 255)", +"hsla(270, 100%, 87.5%, 1.0)", "rgb(223, 191, 255)", +"hsla(300, 100%, 87.5%, 1.0)", "rgb(255, 191, 255)", +"hsla(330, 100%, 87.5%, 1.0)", "rgb(255, 191, 223)", +"hsla(0, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 0%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 12.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 25%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 37.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 50%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 62.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 75%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 87.5%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(30, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(60, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(90, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(120, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(150, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(180, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(210, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(240, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(270, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(300, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(330, 100%, 100%, 1.0)", "rgb(255, 255, 255)", +"hsla(0, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 0%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 12.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 25%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 37.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 50%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 62.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 75%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 87.5%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330, 100%, 0%, 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(30, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(60, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(90, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(120, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(150, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(180, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(210, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(240, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(270, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(300, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(330, 0%, 12.5%, 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(0, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 28, 0.25)", +"hsla(30, 12.5%, 12.5%, 0.25)", "rgba(36, 32, 28, 0.25)", +"hsla(60, 12.5%, 12.5%, 0.25)", "rgba(36, 36, 28, 0.25)", +"hsla(90, 12.5%, 12.5%, 0.25)", "rgba(32, 36, 28, 0.25)", +"hsla(120, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 28, 0.25)", +"hsla(150, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 32, 0.25)", +"hsla(180, 12.5%, 12.5%, 0.25)", "rgba(28, 36, 36, 0.25)", +"hsla(210, 12.5%, 12.5%, 0.25)", "rgba(28, 32, 36, 0.25)", +"hsla(240, 12.5%, 12.5%, 0.25)", "rgba(28, 28, 36, 0.25)", +"hsla(270, 12.5%, 12.5%, 0.25)", "rgba(32, 28, 36, 0.25)", +"hsla(300, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 36, 0.25)", +"hsla(330, 12.5%, 12.5%, 0.25)", "rgba(36, 28, 32, 0.25)", +"hsla(0, 25%, 12.5%, 0.25)", "rgba(40, 24, 24, 0.25)", +"hsla(30, 25%, 12.5%, 0.25)", "rgba(40, 32, 24, 0.25)", +"hsla(60, 25%, 12.5%, 0.25)", "rgba(40, 40, 24, 0.25)", +"hsla(90, 25%, 12.5%, 0.25)", "rgba(32, 40, 24, 0.25)", +"hsla(120, 25%, 12.5%, 0.25)", "rgba(24, 40, 24, 0.25)", +"hsla(150, 25%, 12.5%, 0.25)", "rgba(24, 40, 32, 0.25)", +"hsla(180, 25%, 12.5%, 0.25)", "rgba(24, 40, 40, 0.25)", +"hsla(210, 25%, 12.5%, 0.25)", "rgba(24, 32, 40, 0.25)", +"hsla(240, 25%, 12.5%, 0.25)", "rgba(24, 24, 40, 0.25)", +"hsla(270, 25%, 12.5%, 0.25)", "rgba(32, 24, 40, 0.25)", +"hsla(300, 25%, 12.5%, 0.25)", "rgba(40, 24, 40, 0.25)", +"hsla(330, 25%, 12.5%, 0.25)", "rgba(40, 24, 32, 0.25)", +"hsla(0, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 20, 0.25)", +"hsla(30, 37.5%, 12.5%, 0.25)", "rgba(44, 32, 20, 0.25)", +"hsla(60, 37.5%, 12.5%, 0.25)", "rgba(44, 44, 20, 0.25)", +"hsla(90, 37.5%, 12.5%, 0.25)", "rgba(32, 44, 20, 0.25)", +"hsla(120, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 20, 0.25)", +"hsla(150, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 32, 0.25)", +"hsla(180, 37.5%, 12.5%, 0.25)", "rgba(20, 44, 44, 0.25)", +"hsla(210, 37.5%, 12.5%, 0.25)", "rgba(20, 32, 44, 0.25)", +"hsla(240, 37.5%, 12.5%, 0.25)", "rgba(20, 20, 44, 0.25)", +"hsla(270, 37.5%, 12.5%, 0.25)", "rgba(32, 20, 44, 0.25)", +"hsla(300, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 44, 0.25)", +"hsla(330, 37.5%, 12.5%, 0.25)", "rgba(44, 20, 32, 0.25)", +"hsla(0, 50%, 12.5%, 0.25)", "rgba(48, 16, 16, 0.25)", +"hsla(30, 50%, 12.5%, 0.25)", "rgba(48, 32, 16, 0.25)", +"hsla(60, 50%, 12.5%, 0.25)", "rgba(48, 48, 16, 0.25)", +"hsla(90, 50%, 12.5%, 0.25)", "rgba(32, 48, 16, 0.25)", +"hsla(120, 50%, 12.5%, 0.25)", "rgba(16, 48, 16, 0.25)", +"hsla(150, 50%, 12.5%, 0.25)", "rgba(16, 48, 32, 0.25)", +"hsla(180, 50%, 12.5%, 0.25)", "rgba(16, 48, 48, 0.25)", +"hsla(210, 50%, 12.5%, 0.25)", "rgba(16, 32, 48, 0.25)", +"hsla(240, 50%, 12.5%, 0.25)", "rgba(16, 16, 48, 0.25)", +"hsla(270, 50%, 12.5%, 0.25)", "rgba(32, 16, 48, 0.25)", +"hsla(300, 50%, 12.5%, 0.25)", "rgba(48, 16, 48, 0.25)", +"hsla(330, 50%, 12.5%, 0.25)", "rgba(48, 16, 32, 0.25)", +"hsla(0, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 12, 0.25)", +"hsla(30, 62.5%, 12.5%, 0.25)", "rgba(52, 32, 12, 0.25)", +"hsla(60, 62.5%, 12.5%, 0.25)", "rgba(52, 52, 12, 0.25)", +"hsla(90, 62.5%, 12.5%, 0.25)", "rgba(32, 52, 12, 0.25)", +"hsla(120, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 12, 0.25)", +"hsla(150, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 32, 0.25)", +"hsla(180, 62.5%, 12.5%, 0.25)", "rgba(12, 52, 52, 0.25)", +"hsla(210, 62.5%, 12.5%, 0.25)", "rgba(12, 32, 52, 0.25)", +"hsla(240, 62.5%, 12.5%, 0.25)", "rgba(12, 12, 52, 0.25)", +"hsla(270, 62.5%, 12.5%, 0.25)", "rgba(32, 12, 52, 0.25)", +"hsla(300, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 52, 0.25)", +"hsla(330, 62.5%, 12.5%, 0.25)", "rgba(52, 12, 32, 0.25)", +"hsla(0, 75%, 12.5%, 0.25)", "rgba(56, 8, 8, 0.25)", +"hsla(30, 75%, 12.5%, 0.25)", "rgba(56, 32, 8, 0.25)", +"hsla(60, 75%, 12.5%, 0.25)", "rgba(56, 56, 8, 0.25)", +"hsla(90, 75%, 12.5%, 0.25)", "rgba(32, 56, 8, 0.25)", +"hsla(120, 75%, 12.5%, 0.25)", "rgba(8, 56, 8, 0.25)", +"hsla(150, 75%, 12.5%, 0.25)", "rgba(8, 56, 32, 0.25)", +"hsla(180, 75%, 12.5%, 0.25)", "rgba(8, 56, 56, 0.25)", +"hsla(210, 75%, 12.5%, 0.25)", "rgba(8, 32, 56, 0.25)", +"hsla(240, 75%, 12.5%, 0.25)", "rgba(8, 8, 56, 0.25)", +"hsla(270, 75%, 12.5%, 0.25)", "rgba(32, 8, 56, 0.25)", +"hsla(300, 75%, 12.5%, 0.25)", "rgba(56, 8, 56, 0.25)", +"hsla(330, 75%, 12.5%, 0.25)", "rgba(56, 8, 32, 0.25)", +"hsla(0, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 4, 0.25)", +"hsla(30, 87.5%, 12.5%, 0.25)", "rgba(60, 32, 4, 0.25)", +"hsla(60, 87.5%, 12.5%, 0.25)", "rgba(60, 60, 4, 0.25)", +"hsla(90, 87.5%, 12.5%, 0.25)", "rgba(32, 60, 4, 0.25)", +"hsla(120, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 4, 0.25)", +"hsla(150, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 32, 0.25)", +"hsla(180, 87.5%, 12.5%, 0.25)", "rgba(4, 60, 60, 0.25)", +"hsla(210, 87.5%, 12.5%, 0.25)", "rgba(4, 32, 60, 0.25)", +"hsla(240, 87.5%, 12.5%, 0.25)", "rgba(4, 4, 60, 0.25)", +"hsla(270, 87.5%, 12.5%, 0.25)", "rgba(32, 4, 60, 0.25)", +"hsla(300, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 60, 0.25)", +"hsla(330, 87.5%, 12.5%, 0.25)", "rgba(60, 4, 32, 0.25)", +"hsla(0, 100%, 12.5%, 0.25)", "rgba(64, 0, 0, 0.25)", +"hsla(30, 100%, 12.5%, 0.25)", "rgba(64, 32, 0, 0.25)", +"hsla(60, 100%, 12.5%, 0.25)", "rgba(64, 64, 0, 0.25)", +"hsla(90, 100%, 12.5%, 0.25)", "rgba(32, 64, 0, 0.25)", +"hsla(120, 100%, 12.5%, 0.25)", "rgba(0, 64, 0, 0.25)", +"hsla(150, 100%, 12.5%, 0.25)", "rgba(0, 64, 32, 0.25)", +"hsla(180, 100%, 12.5%, 0.25)", "rgba(0, 64, 64, 0.25)", +"hsla(210, 100%, 12.5%, 0.25)", "rgba(0, 32, 64, 0.25)", +"hsla(240, 100%, 12.5%, 0.25)", "rgba(0, 0, 64, 0.25)", +"hsla(270, 100%, 12.5%, 0.25)", "rgba(32, 0, 64, 0.25)", +"hsla(300, 100%, 12.5%, 0.25)", "rgba(64, 0, 64, 0.25)", +"hsla(330, 100%, 12.5%, 0.25)", "rgba(64, 0, 32, 0.25)", +"hsla(0, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(30, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(60, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(90, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(120, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(150, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(180, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(210, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(240, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(270, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(300, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(330, 0%, 25%, 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(0, 12.5%, 25%, 0.25)", "rgba(72, 56, 56, 0.25)", +"hsla(30, 12.5%, 25%, 0.25)", "rgba(72, 64, 56, 0.25)", +"hsla(60, 12.5%, 25%, 0.25)", "rgba(72, 72, 56, 0.25)", +"hsla(90, 12.5%, 25%, 0.25)", "rgba(64, 72, 56, 0.25)", +"hsla(120, 12.5%, 25%, 0.25)", "rgba(56, 72, 56, 0.25)", +"hsla(150, 12.5%, 25%, 0.25)", "rgba(56, 72, 64, 0.25)", +"hsla(180, 12.5%, 25%, 0.25)", "rgba(56, 72, 72, 0.25)", +"hsla(210, 12.5%, 25%, 0.25)", "rgba(56, 64, 72, 0.25)", +"hsla(240, 12.5%, 25%, 0.25)", "rgba(56, 56, 72, 0.25)", +"hsla(270, 12.5%, 25%, 0.25)", "rgba(64, 56, 72, 0.25)", +"hsla(300, 12.5%, 25%, 0.25)", "rgba(72, 56, 72, 0.25)", +"hsla(330, 12.5%, 25%, 0.25)", "rgba(72, 56, 64, 0.25)", +"hsla(0, 25%, 25%, 0.25)", "rgba(80, 48, 48, 0.25)", +"hsla(30, 25%, 25%, 0.25)", "rgba(80, 64, 48, 0.25)", +"hsla(60, 25%, 25%, 0.25)", "rgba(80, 80, 48, 0.25)", +"hsla(90, 25%, 25%, 0.25)", "rgba(64, 80, 48, 0.25)", +"hsla(120, 25%, 25%, 0.25)", "rgba(48, 80, 48, 0.25)", +"hsla(150, 25%, 25%, 0.25)", "rgba(48, 80, 64, 0.25)", +"hsla(180, 25%, 25%, 0.25)", "rgba(48, 80, 80, 0.25)", +"hsla(210, 25%, 25%, 0.25)", "rgba(48, 64, 80, 0.25)", +"hsla(240, 25%, 25%, 0.25)", "rgba(48, 48, 80, 0.25)", +"hsla(270, 25%, 25%, 0.25)", "rgba(64, 48, 80, 0.25)", +"hsla(300, 25%, 25%, 0.25)", "rgba(80, 48, 80, 0.25)", +"hsla(330, 25%, 25%, 0.25)", "rgba(80, 48, 64, 0.25)", +"hsla(0, 37.5%, 25%, 0.25)", "rgba(88, 40, 40, 0.25)", +"hsla(30, 37.5%, 25%, 0.25)", "rgba(88, 64, 40, 0.25)", +"hsla(60, 37.5%, 25%, 0.25)", "rgba(88, 88, 40, 0.25)", +"hsla(90, 37.5%, 25%, 0.25)", "rgba(64, 88, 40, 0.25)", +"hsla(120, 37.5%, 25%, 0.25)", "rgba(40, 88, 40, 0.25)", +"hsla(150, 37.5%, 25%, 0.25)", "rgba(40, 88, 64, 0.25)", +"hsla(180, 37.5%, 25%, 0.25)", "rgba(40, 88, 88, 0.25)", +"hsla(210, 37.5%, 25%, 0.25)", "rgba(40, 64, 88, 0.25)", +"hsla(240, 37.5%, 25%, 0.25)", "rgba(40, 40, 88, 0.25)", +"hsla(270, 37.5%, 25%, 0.25)", "rgba(64, 40, 88, 0.25)", +"hsla(300, 37.5%, 25%, 0.25)", "rgba(88, 40, 88, 0.25)", +"hsla(330, 37.5%, 25%, 0.25)", "rgba(88, 40, 64, 0.25)", +"hsla(0, 50%, 25%, 0.25)", "rgba(96, 32, 32, 0.25)", +"hsla(30, 50%, 25%, 0.25)", "rgba(96, 64, 32, 0.25)", +"hsla(60, 50%, 25%, 0.25)", "rgba(96, 96, 32, 0.25)", +"hsla(90, 50%, 25%, 0.25)", "rgba(64, 96, 32, 0.25)", +"hsla(120, 50%, 25%, 0.25)", "rgba(32, 96, 32, 0.25)", +"hsla(150, 50%, 25%, 0.25)", "rgba(32, 96, 64, 0.25)", +"hsla(180, 50%, 25%, 0.25)", "rgba(32, 96, 96, 0.25)", +"hsla(210, 50%, 25%, 0.25)", "rgba(32, 64, 96, 0.25)", +"hsla(240, 50%, 25%, 0.25)", "rgba(32, 32, 96, 0.25)", +"hsla(270, 50%, 25%, 0.25)", "rgba(64, 32, 96, 0.25)", +"hsla(300, 50%, 25%, 0.25)", "rgba(96, 32, 96, 0.25)", +"hsla(330, 50%, 25%, 0.25)", "rgba(96, 32, 64, 0.25)", +"hsla(0, 62.5%, 25%, 0.25)", "rgba(104, 24, 24, 0.25)", +"hsla(30, 62.5%, 25%, 0.25)", "rgba(104, 64, 24, 0.25)", +"hsla(60, 62.5%, 25%, 0.25)", "rgba(104, 104, 24, 0.25)", +"hsla(90, 62.5%, 25%, 0.25)", "rgba(64, 104, 24, 0.25)", +"hsla(120, 62.5%, 25%, 0.25)", "rgba(24, 104, 24, 0.25)", +"hsla(150, 62.5%, 25%, 0.25)", "rgba(24, 104, 64, 0.25)", +"hsla(180, 62.5%, 25%, 0.25)", "rgba(24, 104, 104, 0.25)", +"hsla(210, 62.5%, 25%, 0.25)", "rgba(24, 64, 104, 0.25)", +"hsla(240, 62.5%, 25%, 0.25)", "rgba(24, 24, 104, 0.25)", +"hsla(270, 62.5%, 25%, 0.25)", "rgba(64, 24, 104, 0.25)", +"hsla(300, 62.5%, 25%, 0.25)", "rgba(104, 24, 104, 0.25)", +"hsla(330, 62.5%, 25%, 0.25)", "rgba(104, 24, 64, 0.25)", +"hsla(0, 75%, 25%, 0.25)", "rgba(112, 16, 16, 0.25)", +"hsla(30, 75%, 25%, 0.25)", "rgba(112, 64, 16, 0.25)", +"hsla(60, 75%, 25%, 0.25)", "rgba(112, 112, 16, 0.25)", +"hsla(90, 75%, 25%, 0.25)", "rgba(64, 112, 16, 0.25)", +"hsla(120, 75%, 25%, 0.25)", "rgba(16, 112, 16, 0.25)", +"hsla(150, 75%, 25%, 0.25)", "rgba(16, 112, 64, 0.25)", +"hsla(180, 75%, 25%, 0.25)", "rgba(16, 112, 112, 0.25)", +"hsla(210, 75%, 25%, 0.25)", "rgba(16, 64, 112, 0.25)", +"hsla(240, 75%, 25%, 0.25)", "rgba(16, 16, 112, 0.25)", +"hsla(270, 75%, 25%, 0.25)", "rgba(64, 16, 112, 0.25)", +"hsla(300, 75%, 25%, 0.25)", "rgba(112, 16, 112, 0.25)", +"hsla(330, 75%, 25%, 0.25)", "rgba(112, 16, 64, 0.25)", +"hsla(0, 87.5%, 25%, 0.25)", "rgba(120, 8, 8, 0.25)", +"hsla(30, 87.5%, 25%, 0.25)", "rgba(120, 64, 8, 0.25)", +"hsla(60, 87.5%, 25%, 0.25)", "rgba(120, 120, 8, 0.25)", +"hsla(90, 87.5%, 25%, 0.25)", "rgba(64, 120, 8, 0.25)", +"hsla(120, 87.5%, 25%, 0.25)", "rgba(8, 120, 8, 0.25)", +"hsla(150, 87.5%, 25%, 0.25)", "rgba(8, 120, 64, 0.25)", +"hsla(180, 87.5%, 25%, 0.25)", "rgba(8, 120, 120, 0.25)", +"hsla(210, 87.5%, 25%, 0.25)", "rgba(8, 64, 120, 0.25)", +"hsla(240, 87.5%, 25%, 0.25)", "rgba(8, 8, 120, 0.25)", +"hsla(270, 87.5%, 25%, 0.25)", "rgba(64, 8, 120, 0.25)", +"hsla(300, 87.5%, 25%, 0.25)", "rgba(120, 8, 120, 0.25)", +"hsla(330, 87.5%, 25%, 0.25)", "rgba(120, 8, 64, 0.25)", +"hsla(0, 100%, 25%, 0.25)", "rgba(128, 0, 0, 0.25)", +"hsla(30, 100%, 25%, 0.25)", "rgba(128, 64, 0, 0.25)", +"hsla(60, 100%, 25%, 0.25)", "rgba(128, 128, 0, 0.25)", +"hsla(90, 100%, 25%, 0.25)", "rgba(64, 128, 0, 0.25)", +"hsla(120, 100%, 25%, 0.25)", "rgba(0, 128, 0, 0.25)", +"hsla(150, 100%, 25%, 0.25)", "rgba(0, 128, 64, 0.25)", +"hsla(180, 100%, 25%, 0.25)", "rgba(0, 128, 128, 0.25)", +"hsla(210, 100%, 25%, 0.25)", "rgba(0, 64, 128, 0.25)", +"hsla(240, 100%, 25%, 0.25)", "rgba(0, 0, 128, 0.25)", +"hsla(270, 100%, 25%, 0.25)", "rgba(64, 0, 128, 0.25)", +"hsla(300, 100%, 25%, 0.25)", "rgba(128, 0, 128, 0.25)", +"hsla(330, 100%, 25%, 0.25)", "rgba(128, 0, 64, 0.25)", +"hsla(0, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(30, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(60, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(90, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(120, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(150, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(180, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(210, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(240, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(270, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(300, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(330, 0%, 37.5%, 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(0, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 84, 0.25)", +"hsla(30, 12.5%, 37.5%, 0.25)", "rgba(108, 96, 84, 0.25)", +"hsla(60, 12.5%, 37.5%, 0.25)", "rgba(108, 108, 84, 0.25)", +"hsla(90, 12.5%, 37.5%, 0.25)", "rgba(96, 108, 84, 0.25)", +"hsla(120, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 84, 0.25)", +"hsla(150, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 96, 0.25)", +"hsla(180, 12.5%, 37.5%, 0.25)", "rgba(84, 108, 108, 0.25)", +"hsla(210, 12.5%, 37.5%, 0.25)", "rgba(84, 96, 108, 0.25)", +"hsla(240, 12.5%, 37.5%, 0.25)", "rgba(84, 84, 108, 0.25)", +"hsla(270, 12.5%, 37.5%, 0.25)", "rgba(96, 84, 108, 0.25)", +"hsla(300, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 108, 0.25)", +"hsla(330, 12.5%, 37.5%, 0.25)", "rgba(108, 84, 96, 0.25)", +"hsla(0, 25%, 37.5%, 0.25)", "rgba(120, 72, 72, 0.25)", +"hsla(30, 25%, 37.5%, 0.25)", "rgba(120, 96, 72, 0.25)", +"hsla(60, 25%, 37.5%, 0.25)", "rgba(120, 120, 72, 0.25)", +"hsla(90, 25%, 37.5%, 0.25)", "rgba(96, 120, 72, 0.25)", +"hsla(120, 25%, 37.5%, 0.25)", "rgba(72, 120, 72, 0.25)", +"hsla(150, 25%, 37.5%, 0.25)", "rgba(72, 120, 96, 0.25)", +"hsla(180, 25%, 37.5%, 0.25)", "rgba(72, 120, 120, 0.25)", +"hsla(210, 25%, 37.5%, 0.25)", "rgba(72, 96, 120, 0.25)", +"hsla(240, 25%, 37.5%, 0.25)", "rgba(72, 72, 120, 0.25)", +"hsla(270, 25%, 37.5%, 0.25)", "rgba(96, 72, 120, 0.25)", +"hsla(300, 25%, 37.5%, 0.25)", "rgba(120, 72, 120, 0.25)", +"hsla(330, 25%, 37.5%, 0.25)", "rgba(120, 72, 96, 0.25)", +"hsla(0, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 60, 0.25)", +"hsla(30, 37.5%, 37.5%, 0.25)", "rgba(131, 96, 60, 0.25)", +"hsla(60, 37.5%, 37.5%, 0.25)", "rgba(131, 131, 60, 0.25)", +"hsla(90, 37.5%, 37.5%, 0.25)", "rgba(96, 131, 60, 0.25)", +"hsla(120, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 60, 0.25)", +"hsla(150, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 96, 0.25)", +"hsla(180, 37.5%, 37.5%, 0.25)", "rgba(60, 131, 131, 0.25)", +"hsla(210, 37.5%, 37.5%, 0.25)", "rgba(60, 96, 131, 0.25)", +"hsla(240, 37.5%, 37.5%, 0.25)", "rgba(60, 60, 131, 0.25)", +"hsla(270, 37.5%, 37.5%, 0.25)", "rgba(96, 60, 131, 0.25)", +"hsla(300, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 131, 0.25)", +"hsla(330, 37.5%, 37.5%, 0.25)", "rgba(131, 60, 96, 0.25)", +"hsla(0, 50%, 37.5%, 0.25)", "rgba(143, 48, 48, 0.25)", +"hsla(30, 50%, 37.5%, 0.25)", "rgba(143, 96, 48, 0.25)", +"hsla(60, 50%, 37.5%, 0.25)", "rgba(143, 143, 48, 0.25)", +"hsla(90, 50%, 37.5%, 0.25)", "rgba(96, 143, 48, 0.25)", +"hsla(120, 50%, 37.5%, 0.25)", "rgba(48, 143, 48, 0.25)", +"hsla(150, 50%, 37.5%, 0.25)", "rgba(48, 143, 96, 0.25)", +"hsla(180, 50%, 37.5%, 0.25)", "rgba(48, 143, 143, 0.25)", +"hsla(210, 50%, 37.5%, 0.25)", "rgba(48, 96, 143, 0.25)", +"hsla(240, 50%, 37.5%, 0.25)", "rgba(48, 48, 143, 0.25)", +"hsla(270, 50%, 37.5%, 0.25)", "rgba(96, 48, 143, 0.25)", +"hsla(300, 50%, 37.5%, 0.25)", "rgba(143, 48, 143, 0.25)", +"hsla(330, 50%, 37.5%, 0.25)", "rgba(143, 48, 96, 0.25)", +"hsla(0, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 36, 0.25)", +"hsla(30, 62.5%, 37.5%, 0.25)", "rgba(155, 96, 36, 0.25)", +"hsla(60, 62.5%, 37.5%, 0.25)", "rgba(155, 155, 36, 0.25)", +"hsla(90, 62.5%, 37.5%, 0.25)", "rgba(96, 155, 36, 0.25)", +"hsla(120, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 36, 0.25)", +"hsla(150, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 96, 0.25)", +"hsla(180, 62.5%, 37.5%, 0.25)", "rgba(36, 155, 155, 0.25)", +"hsla(210, 62.5%, 37.5%, 0.25)", "rgba(36, 96, 155, 0.25)", +"hsla(240, 62.5%, 37.5%, 0.25)", "rgba(36, 36, 155, 0.25)", +"hsla(270, 62.5%, 37.5%, 0.25)", "rgba(96, 36, 155, 0.25)", +"hsla(300, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 155, 0.25)", +"hsla(330, 62.5%, 37.5%, 0.25)", "rgba(155, 36, 96, 0.25)", +"hsla(0, 75%, 37.5%, 0.25)", "rgba(167, 24, 24, 0.25)", +"hsla(30, 75%, 37.5%, 0.25)", "rgba(167, 96, 24, 0.25)", +"hsla(60, 75%, 37.5%, 0.25)", "rgba(167, 167, 24, 0.25)", +"hsla(90, 75%, 37.5%, 0.25)", "rgba(96, 167, 24, 0.25)", +"hsla(120, 75%, 37.5%, 0.25)", "rgba(24, 167, 24, 0.25)", +"hsla(150, 75%, 37.5%, 0.25)", "rgba(24, 167, 96, 0.25)", +"hsla(180, 75%, 37.5%, 0.25)", "rgba(24, 167, 167, 0.25)", +"hsla(210, 75%, 37.5%, 0.25)", "rgba(24, 96, 167, 0.25)", +"hsla(240, 75%, 37.5%, 0.25)", "rgba(24, 24, 167, 0.25)", +"hsla(270, 75%, 37.5%, 0.25)", "rgba(96, 24, 167, 0.25)", +"hsla(300, 75%, 37.5%, 0.25)", "rgba(167, 24, 167, 0.25)", +"hsla(330, 75%, 37.5%, 0.25)", "rgba(167, 24, 96, 0.25)", +"hsla(0, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 12, 0.25)", +"hsla(30, 87.5%, 37.5%, 0.25)", "rgba(179, 96, 12, 0.25)", +"hsla(60, 87.5%, 37.5%, 0.25)", "rgba(179, 179, 12, 0.25)", +"hsla(90, 87.5%, 37.5%, 0.25)", "rgba(96, 179, 12, 0.25)", +"hsla(120, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 12, 0.25)", +"hsla(150, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 96, 0.25)", +"hsla(180, 87.5%, 37.5%, 0.25)", "rgba(12, 179, 179, 0.25)", +"hsla(210, 87.5%, 37.5%, 0.25)", "rgba(12, 96, 179, 0.25)", +"hsla(240, 87.5%, 37.5%, 0.25)", "rgba(12, 12, 179, 0.25)", +"hsla(270, 87.5%, 37.5%, 0.25)", "rgba(96, 12, 179, 0.25)", +"hsla(300, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 179, 0.25)", +"hsla(330, 87.5%, 37.5%, 0.25)", "rgba(179, 12, 96, 0.25)", +"hsla(0, 100%, 37.5%, 0.25)", "rgba(191, 0, 0, 0.25)", +"hsla(30, 100%, 37.5%, 0.25)", "rgba(191, 96, 0, 0.25)", +"hsla(60, 100%, 37.5%, 0.25)", "rgba(191, 191, 0, 0.25)", +"hsla(90, 100%, 37.5%, 0.25)", "rgba(96, 191, 0, 0.25)", +"hsla(120, 100%, 37.5%, 0.25)", "rgba(0, 191, 0, 0.25)", +"hsla(150, 100%, 37.5%, 0.25)", "rgba(0, 191, 96, 0.25)", +"hsla(180, 100%, 37.5%, 0.25)", "rgba(0, 191, 191, 0.25)", +"hsla(210, 100%, 37.5%, 0.25)", "rgba(0, 96, 191, 0.25)", +"hsla(240, 100%, 37.5%, 0.25)", "rgba(0, 0, 191, 0.25)", +"hsla(270, 100%, 37.5%, 0.25)", "rgba(96, 0, 191, 0.25)", +"hsla(300, 100%, 37.5%, 0.25)", "rgba(191, 0, 191, 0.25)", +"hsla(330, 100%, 37.5%, 0.25)", "rgba(191, 0, 96, 0.25)", +"hsla(0, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(30, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(60, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(90, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(120, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(150, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(180, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(210, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(240, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(270, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(300, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(330, 0%, 50%, 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(0, 12.5%, 50%, 0.25)", "rgba(143, 112, 112, 0.25)", +"hsla(30, 12.5%, 50%, 0.25)", "rgba(143, 128, 112, 0.25)", +"hsla(60, 12.5%, 50%, 0.25)", "rgba(143, 143, 112, 0.25)", +"hsla(90, 12.5%, 50%, 0.25)", "rgba(128, 143, 112, 0.25)", +"hsla(120, 12.5%, 50%, 0.25)", "rgba(112, 143, 112, 0.25)", +"hsla(150, 12.5%, 50%, 0.25)", "rgba(112, 143, 128, 0.25)", +"hsla(180, 12.5%, 50%, 0.25)", "rgba(112, 143, 143, 0.25)", +"hsla(210, 12.5%, 50%, 0.25)", "rgba(112, 128, 143, 0.25)", +"hsla(240, 12.5%, 50%, 0.25)", "rgba(112, 112, 143, 0.25)", +"hsla(270, 12.5%, 50%, 0.25)", "rgba(128, 112, 143, 0.25)", +"hsla(300, 12.5%, 50%, 0.25)", "rgba(143, 112, 143, 0.25)", +"hsla(330, 12.5%, 50%, 0.25)", "rgba(143, 112, 128, 0.25)", +"hsla(0, 25%, 50%, 0.25)", "rgba(159, 96, 96, 0.25)", +"hsla(30, 25%, 50%, 0.25)", "rgba(159, 128, 96, 0.25)", +"hsla(60, 25%, 50%, 0.25)", "rgba(159, 159, 96, 0.25)", +"hsla(90, 25%, 50%, 0.25)", "rgba(128, 159, 96, 0.25)", +"hsla(120, 25%, 50%, 0.25)", "rgba(96, 159, 96, 0.25)", +"hsla(150, 25%, 50%, 0.25)", "rgba(96, 159, 128, 0.25)", +"hsla(180, 25%, 50%, 0.25)", "rgba(96, 159, 159, 0.25)", +"hsla(210, 25%, 50%, 0.25)", "rgba(96, 128, 159, 0.25)", +"hsla(240, 25%, 50%, 0.25)", "rgba(96, 96, 159, 0.25)", +"hsla(270, 25%, 50%, 0.25)", "rgba(128, 96, 159, 0.25)", +"hsla(300, 25%, 50%, 0.25)", "rgba(159, 96, 159, 0.25)", +"hsla(330, 25%, 50%, 0.25)", "rgba(159, 96, 128, 0.25)", +"hsla(0, 37.5%, 50%, 0.25)", "rgba(175, 80, 80, 0.25)", +"hsla(30, 37.5%, 50%, 0.25)", "rgba(175, 128, 80, 0.25)", +"hsla(60, 37.5%, 50%, 0.25)", "rgba(175, 175, 80, 0.25)", +"hsla(90, 37.5%, 50%, 0.25)", "rgba(128, 175, 80, 0.25)", +"hsla(120, 37.5%, 50%, 0.25)", "rgba(80, 175, 80, 0.25)", +"hsla(150, 37.5%, 50%, 0.25)", "rgba(80, 175, 128, 0.25)", +"hsla(180, 37.5%, 50%, 0.25)", "rgba(80, 175, 175, 0.25)", +"hsla(210, 37.5%, 50%, 0.25)", "rgba(80, 128, 175, 0.25)", +"hsla(240, 37.5%, 50%, 0.25)", "rgba(80, 80, 175, 0.25)", +"hsla(270, 37.5%, 50%, 0.25)", "rgba(128, 80, 175, 0.25)", +"hsla(300, 37.5%, 50%, 0.25)", "rgba(175, 80, 175, 0.25)", +"hsla(330, 37.5%, 50%, 0.25)", "rgba(175, 80, 128, 0.25)", +"hsla(0, 50%, 50%, 0.25)", "rgba(191, 64, 64, 0.25)", +"hsla(30, 50%, 50%, 0.25)", "rgba(191, 128, 64, 0.25)", +"hsla(60, 50%, 50%, 0.25)", "rgba(191, 191, 64, 0.25)", +"hsla(90, 50%, 50%, 0.25)", "rgba(128, 191, 64, 0.25)", +"hsla(120, 50%, 50%, 0.25)", "rgba(64, 191, 64, 0.25)", +"hsla(150, 50%, 50%, 0.25)", "rgba(64, 191, 128, 0.25)", +"hsla(180, 50%, 50%, 0.25)", "rgba(64, 191, 191, 0.25)", +"hsla(210, 50%, 50%, 0.25)", "rgba(64, 128, 191, 0.25)", +"hsla(240, 50%, 50%, 0.25)", "rgba(64, 64, 191, 0.25)", +"hsla(270, 50%, 50%, 0.25)", "rgba(128, 64, 191, 0.25)", +"hsla(300, 50%, 50%, 0.25)", "rgba(191, 64, 191, 0.25)", +"hsla(330, 50%, 50%, 0.25)", "rgba(191, 64, 128, 0.25)", +"hsla(0, 62.5%, 50%, 0.25)", "rgba(207, 48, 48, 0.25)", +"hsla(30, 62.5%, 50%, 0.25)", "rgba(207, 128, 48, 0.25)", +"hsla(60, 62.5%, 50%, 0.25)", "rgba(207, 207, 48, 0.25)", +"hsla(90, 62.5%, 50%, 0.25)", "rgba(128, 207, 48, 0.25)", +"hsla(120, 62.5%, 50%, 0.25)", "rgba(48, 207, 48, 0.25)", +"hsla(150, 62.5%, 50%, 0.25)", "rgba(48, 207, 128, 0.25)", +"hsla(180, 62.5%, 50%, 0.25)", "rgba(48, 207, 207, 0.25)", +"hsla(210, 62.5%, 50%, 0.25)", "rgba(48, 128, 207, 0.25)", +"hsla(240, 62.5%, 50%, 0.25)", "rgba(48, 48, 207, 0.25)", +"hsla(270, 62.5%, 50%, 0.25)", "rgba(128, 48, 207, 0.25)", +"hsla(300, 62.5%, 50%, 0.25)", "rgba(207, 48, 207, 0.25)", +"hsla(330, 62.5%, 50%, 0.25)", "rgba(207, 48, 128, 0.25)", +"hsla(0, 75%, 50%, 0.25)", "rgba(223, 32, 32, 0.25)", +"hsla(30, 75%, 50%, 0.25)", "rgba(223, 128, 32, 0.25)", +"hsla(60, 75%, 50%, 0.25)", "rgba(223, 223, 32, 0.25)", +"hsla(90, 75%, 50%, 0.25)", "rgba(128, 223, 32, 0.25)", +"hsla(120, 75%, 50%, 0.25)", "rgba(32, 223, 32, 0.25)", +"hsla(150, 75%, 50%, 0.25)", "rgba(32, 223, 128, 0.25)", +"hsla(180, 75%, 50%, 0.25)", "rgba(32, 223, 223, 0.25)", +"hsla(210, 75%, 50%, 0.25)", "rgba(32, 128, 223, 0.25)", +"hsla(240, 75%, 50%, 0.25)", "rgba(32, 32, 223, 0.25)", +"hsla(270, 75%, 50%, 0.25)", "rgba(128, 32, 223, 0.25)", +"hsla(300, 75%, 50%, 0.25)", "rgba(223, 32, 223, 0.25)", +"hsla(330, 75%, 50%, 0.25)", "rgba(223, 32, 128, 0.25)", +"hsla(0, 87.5%, 50%, 0.25)", "rgba(239, 16, 16, 0.25)", +"hsla(30, 87.5%, 50%, 0.25)", "rgba(239, 128, 16, 0.25)", +"hsla(60, 87.5%, 50%, 0.25)", "rgba(239, 239, 16, 0.25)", +"hsla(90, 87.5%, 50%, 0.25)", "rgba(128, 239, 16, 0.25)", +"hsla(120, 87.5%, 50%, 0.25)", "rgba(16, 239, 16, 0.25)", +"hsla(150, 87.5%, 50%, 0.25)", "rgba(16, 239, 128, 0.25)", +"hsla(180, 87.5%, 50%, 0.25)", "rgba(16, 239, 239, 0.25)", +"hsla(210, 87.5%, 50%, 0.25)", "rgba(16, 128, 239, 0.25)", +"hsla(240, 87.5%, 50%, 0.25)", "rgba(16, 16, 239, 0.25)", +"hsla(270, 87.5%, 50%, 0.25)", "rgba(128, 16, 239, 0.25)", +"hsla(300, 87.5%, 50%, 0.25)", "rgba(239, 16, 239, 0.25)", +"hsla(330, 87.5%, 50%, 0.25)", "rgba(239, 16, 128, 0.25)", +"hsla(0, 100%, 50%, 0.25)", "rgba(255, 0, 0, 0.25)", +"hsla(30, 100%, 50%, 0.25)", "rgba(255, 128, 0, 0.25)", +"hsla(60, 100%, 50%, 0.25)", "rgba(255, 255, 0, 0.25)", +"hsla(90, 100%, 50%, 0.25)", "rgba(128, 255, 0, 0.25)", +"hsla(120, 100%, 50%, 0.25)", "rgba(0, 255, 0, 0.25)", +"hsla(150, 100%, 50%, 0.25)", "rgba(0, 255, 128, 0.25)", +"hsla(180, 100%, 50%, 0.25)", "rgba(0, 255, 255, 0.25)", +"hsla(210, 100%, 50%, 0.25)", "rgba(0, 128, 255, 0.25)", +"hsla(240, 100%, 50%, 0.25)", "rgba(0, 0, 255, 0.25)", +"hsla(270, 100%, 50%, 0.25)", "rgba(128, 0, 255, 0.25)", +"hsla(300, 100%, 50%, 0.25)", "rgba(255, 0, 255, 0.25)", +"hsla(330, 100%, 50%, 0.25)", "rgba(255, 0, 128, 0.25)", +"hsla(0, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(30, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(60, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(90, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(120, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(150, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(180, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(210, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(240, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(270, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(300, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(330, 0%, 62.5%, 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(0, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 147, 0.25)", +"hsla(30, 12.5%, 62.5%, 0.25)", "rgba(171, 159, 147, 0.25)", +"hsla(60, 12.5%, 62.5%, 0.25)", "rgba(171, 171, 147, 0.25)", +"hsla(90, 12.5%, 62.5%, 0.25)", "rgba(159, 171, 147, 0.25)", +"hsla(120, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 147, 0.25)", +"hsla(150, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 159, 0.25)", +"hsla(180, 12.5%, 62.5%, 0.25)", "rgba(147, 171, 171, 0.25)", +"hsla(210, 12.5%, 62.5%, 0.25)", "rgba(147, 159, 171, 0.25)", +"hsla(240, 12.5%, 62.5%, 0.25)", "rgba(147, 147, 171, 0.25)", +"hsla(270, 12.5%, 62.5%, 0.25)", "rgba(159, 147, 171, 0.25)", +"hsla(300, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 171, 0.25)", +"hsla(330, 12.5%, 62.5%, 0.25)", "rgba(171, 147, 159, 0.25)", +"hsla(0, 25%, 62.5%, 0.25)", "rgba(183, 135, 135, 0.25)", +"hsla(30, 25%, 62.5%, 0.25)", "rgba(183, 159, 135, 0.25)", +"hsla(60, 25%, 62.5%, 0.25)", "rgba(183, 183, 135, 0.25)", +"hsla(90, 25%, 62.5%, 0.25)", "rgba(159, 183, 135, 0.25)", +"hsla(120, 25%, 62.5%, 0.25)", "rgba(135, 183, 135, 0.25)", +"hsla(150, 25%, 62.5%, 0.25)", "rgba(135, 183, 159, 0.25)", +"hsla(180, 25%, 62.5%, 0.25)", "rgba(135, 183, 183, 0.25)", +"hsla(210, 25%, 62.5%, 0.25)", "rgba(135, 159, 183, 0.25)", +"hsla(240, 25%, 62.5%, 0.25)", "rgba(135, 135, 183, 0.25)", +"hsla(270, 25%, 62.5%, 0.25)", "rgba(159, 135, 183, 0.25)", +"hsla(300, 25%, 62.5%, 0.25)", "rgba(183, 135, 183, 0.25)", +"hsla(330, 25%, 62.5%, 0.25)", "rgba(183, 135, 159, 0.25)", +"hsla(0, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 124, 0.25)", +"hsla(30, 37.5%, 62.5%, 0.25)", "rgba(195, 159, 124, 0.25)", +"hsla(60, 37.5%, 62.5%, 0.25)", "rgba(195, 195, 124, 0.25)", +"hsla(90, 37.5%, 62.5%, 0.25)", "rgba(159, 195, 124, 0.25)", +"hsla(120, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 124, 0.25)", +"hsla(150, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 159, 0.25)", +"hsla(180, 37.5%, 62.5%, 0.25)", "rgba(124, 195, 195, 0.25)", +"hsla(210, 37.5%, 62.5%, 0.25)", "rgba(124, 159, 195, 0.25)", +"hsla(240, 37.5%, 62.5%, 0.25)", "rgba(124, 124, 195, 0.25)", +"hsla(270, 37.5%, 62.5%, 0.25)", "rgba(159, 124, 195, 0.25)", +"hsla(300, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 195, 0.25)", +"hsla(330, 37.5%, 62.5%, 0.25)", "rgba(195, 124, 159, 0.25)", +"hsla(0, 50%, 62.5%, 0.25)", "rgba(207, 112, 112, 0.25)", +"hsla(30, 50%, 62.5%, 0.25)", "rgba(207, 159, 112, 0.25)", +"hsla(60, 50%, 62.5%, 0.25)", "rgba(207, 207, 112, 0.25)", +"hsla(90, 50%, 62.5%, 0.25)", "rgba(159, 207, 112, 0.25)", +"hsla(120, 50%, 62.5%, 0.25)", "rgba(112, 207, 112, 0.25)", +"hsla(150, 50%, 62.5%, 0.25)", "rgba(112, 207, 159, 0.25)", +"hsla(180, 50%, 62.5%, 0.25)", "rgba(112, 207, 207, 0.25)", +"hsla(210, 50%, 62.5%, 0.25)", "rgba(112, 159, 207, 0.25)", +"hsla(240, 50%, 62.5%, 0.25)", "rgba(112, 112, 207, 0.25)", +"hsla(270, 50%, 62.5%, 0.25)", "rgba(159, 112, 207, 0.25)", +"hsla(300, 50%, 62.5%, 0.25)", "rgba(207, 112, 207, 0.25)", +"hsla(330, 50%, 62.5%, 0.25)", "rgba(207, 112, 159, 0.25)", +"hsla(0, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 100, 0.25)", +"hsla(30, 62.5%, 62.5%, 0.25)", "rgba(219, 159, 100, 0.25)", +"hsla(60, 62.5%, 62.5%, 0.25)", "rgba(219, 219, 100, 0.25)", +"hsla(90, 62.5%, 62.5%, 0.25)", "rgba(159, 219, 100, 0.25)", +"hsla(120, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 100, 0.25)", +"hsla(150, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 159, 0.25)", +"hsla(180, 62.5%, 62.5%, 0.25)", "rgba(100, 219, 219, 0.25)", +"hsla(210, 62.5%, 62.5%, 0.25)", "rgba(100, 159, 219, 0.25)", +"hsla(240, 62.5%, 62.5%, 0.25)", "rgba(100, 100, 219, 0.25)", +"hsla(270, 62.5%, 62.5%, 0.25)", "rgba(159, 100, 219, 0.25)", +"hsla(300, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 219, 0.25)", +"hsla(330, 62.5%, 62.5%, 0.25)", "rgba(219, 100, 159, 0.25)", +"hsla(0, 75%, 62.5%, 0.25)", "rgba(231, 88, 88, 0.25)", +"hsla(30, 75%, 62.5%, 0.25)", "rgba(231, 159, 88, 0.25)", +"hsla(60, 75%, 62.5%, 0.25)", "rgba(231, 231, 88, 0.25)", +"hsla(90, 75%, 62.5%, 0.25)", "rgba(159, 231, 88, 0.25)", +"hsla(120, 75%, 62.5%, 0.25)", "rgba(88, 231, 88, 0.25)", +"hsla(150, 75%, 62.5%, 0.25)", "rgba(88, 231, 159, 0.25)", +"hsla(180, 75%, 62.5%, 0.25)", "rgba(88, 231, 231, 0.25)", +"hsla(210, 75%, 62.5%, 0.25)", "rgba(88, 159, 231, 0.25)", +"hsla(240, 75%, 62.5%, 0.25)", "rgba(88, 88, 231, 0.25)", +"hsla(270, 75%, 62.5%, 0.25)", "rgba(159, 88, 231, 0.25)", +"hsla(300, 75%, 62.5%, 0.25)", "rgba(231, 88, 231, 0.25)", +"hsla(330, 75%, 62.5%, 0.25)", "rgba(231, 88, 159, 0.25)", +"hsla(0, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 76, 0.25)", +"hsla(30, 87.5%, 62.5%, 0.25)", "rgba(243, 159, 76, 0.25)", +"hsla(60, 87.5%, 62.5%, 0.25)", "rgba(243, 243, 76, 0.25)", +"hsla(90, 87.5%, 62.5%, 0.25)", "rgba(159, 243, 76, 0.25)", +"hsla(120, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 76, 0.25)", +"hsla(150, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 159, 0.25)", +"hsla(180, 87.5%, 62.5%, 0.25)", "rgba(76, 243, 243, 0.25)", +"hsla(210, 87.5%, 62.5%, 0.25)", "rgba(76, 159, 243, 0.25)", +"hsla(240, 87.5%, 62.5%, 0.25)", "rgba(76, 76, 243, 0.25)", +"hsla(270, 87.5%, 62.5%, 0.25)", "rgba(159, 76, 243, 0.25)", +"hsla(300, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 243, 0.25)", +"hsla(330, 87.5%, 62.5%, 0.25)", "rgba(243, 76, 159, 0.25)", +"hsla(0, 100%, 62.5%, 0.25)", "rgba(255, 64, 64, 0.25)", +"hsla(30, 100%, 62.5%, 0.25)", "rgba(255, 159, 64, 0.25)", +"hsla(60, 100%, 62.5%, 0.25)", "rgba(255, 255, 64, 0.25)", +"hsla(90, 100%, 62.5%, 0.25)", "rgba(159, 255, 64, 0.25)", +"hsla(120, 100%, 62.5%, 0.25)", "rgba(64, 255, 64, 0.25)", +"hsla(150, 100%, 62.5%, 0.25)", "rgba(64, 255, 159, 0.25)", +"hsla(180, 100%, 62.5%, 0.25)", "rgba(64, 255, 255, 0.25)", +"hsla(210, 100%, 62.5%, 0.25)", "rgba(64, 159, 255, 0.25)", +"hsla(240, 100%, 62.5%, 0.25)", "rgba(64, 64, 255, 0.25)", +"hsla(270, 100%, 62.5%, 0.25)", "rgba(159, 64, 255, 0.25)", +"hsla(300, 100%, 62.5%, 0.25)", "rgba(255, 64, 255, 0.25)", +"hsla(330, 100%, 62.5%, 0.25)", "rgba(255, 64, 159, 0.25)", +"hsla(0, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(30, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(60, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(90, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(120, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(150, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(180, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(210, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(240, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(270, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(300, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(330, 0%, 75%, 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(0, 12.5%, 75%, 0.25)", "rgba(199, 183, 183, 0.25)", +"hsla(30, 12.5%, 75%, 0.25)", "rgba(199, 191, 183, 0.25)", +"hsla(60, 12.5%, 75%, 0.25)", "rgba(199, 199, 183, 0.25)", +"hsla(90, 12.5%, 75%, 0.25)", "rgba(191, 199, 183, 0.25)", +"hsla(120, 12.5%, 75%, 0.25)", "rgba(183, 199, 183, 0.25)", +"hsla(150, 12.5%, 75%, 0.25)", "rgba(183, 199, 191, 0.25)", +"hsla(180, 12.5%, 75%, 0.25)", "rgba(183, 199, 199, 0.25)", +"hsla(210, 12.5%, 75%, 0.25)", "rgba(183, 191, 199, 0.25)", +"hsla(240, 12.5%, 75%, 0.25)", "rgba(183, 183, 199, 0.25)", +"hsla(270, 12.5%, 75%, 0.25)", "rgba(191, 183, 199, 0.25)", +"hsla(300, 12.5%, 75%, 0.25)", "rgba(199, 183, 199, 0.25)", +"hsla(330, 12.5%, 75%, 0.25)", "rgba(199, 183, 191, 0.25)", +"hsla(0, 25%, 75%, 0.25)", "rgba(207, 175, 175, 0.25)", +"hsla(30, 25%, 75%, 0.25)", "rgba(207, 191, 175, 0.25)", +"hsla(60, 25%, 75%, 0.25)", "rgba(207, 207, 175, 0.25)", +"hsla(90, 25%, 75%, 0.25)", "rgba(191, 207, 175, 0.25)", +"hsla(120, 25%, 75%, 0.25)", "rgba(175, 207, 175, 0.25)", +"hsla(150, 25%, 75%, 0.25)", "rgba(175, 207, 191, 0.25)", +"hsla(180, 25%, 75%, 0.25)", "rgba(175, 207, 207, 0.25)", +"hsla(210, 25%, 75%, 0.25)", "rgba(175, 191, 207, 0.25)", +"hsla(240, 25%, 75%, 0.25)", "rgba(175, 175, 207, 0.25)", +"hsla(270, 25%, 75%, 0.25)", "rgba(191, 175, 207, 0.25)", +"hsla(300, 25%, 75%, 0.25)", "rgba(207, 175, 207, 0.25)", +"hsla(330, 25%, 75%, 0.25)", "rgba(207, 175, 191, 0.25)", +"hsla(0, 37.5%, 75%, 0.25)", "rgba(215, 167, 167, 0.25)", +"hsla(30, 37.5%, 75%, 0.25)", "rgba(215, 191, 167, 0.25)", +"hsla(60, 37.5%, 75%, 0.25)", "rgba(215, 215, 167, 0.25)", +"hsla(90, 37.5%, 75%, 0.25)", "rgba(191, 215, 167, 0.25)", +"hsla(120, 37.5%, 75%, 0.25)", "rgba(167, 215, 167, 0.25)", +"hsla(150, 37.5%, 75%, 0.25)", "rgba(167, 215, 191, 0.25)", +"hsla(180, 37.5%, 75%, 0.25)", "rgba(167, 215, 215, 0.25)", +"hsla(210, 37.5%, 75%, 0.25)", "rgba(167, 191, 215, 0.25)", +"hsla(240, 37.5%, 75%, 0.25)", "rgba(167, 167, 215, 0.25)", +"hsla(270, 37.5%, 75%, 0.25)", "rgba(191, 167, 215, 0.25)", +"hsla(300, 37.5%, 75%, 0.25)", "rgba(215, 167, 215, 0.25)", +"hsla(330, 37.5%, 75%, 0.25)", "rgba(215, 167, 191, 0.25)", +"hsla(0, 50%, 75%, 0.25)", "rgba(223, 159, 159, 0.25)", +"hsla(30, 50%, 75%, 0.25)", "rgba(223, 191, 159, 0.25)", +"hsla(60, 50%, 75%, 0.25)", "rgba(223, 223, 159, 0.25)", +"hsla(90, 50%, 75%, 0.25)", "rgba(191, 223, 159, 0.25)", +"hsla(120, 50%, 75%, 0.25)", "rgba(159, 223, 159, 0.25)", +"hsla(150, 50%, 75%, 0.25)", "rgba(159, 223, 191, 0.25)", +"hsla(180, 50%, 75%, 0.25)", "rgba(159, 223, 223, 0.25)", +"hsla(210, 50%, 75%, 0.25)", "rgba(159, 191, 223, 0.25)", +"hsla(240, 50%, 75%, 0.25)", "rgba(159, 159, 223, 0.25)", +"hsla(270, 50%, 75%, 0.25)", "rgba(191, 159, 223, 0.25)", +"hsla(300, 50%, 75%, 0.25)", "rgba(223, 159, 223, 0.25)", +"hsla(330, 50%, 75%, 0.25)", "rgba(223, 159, 191, 0.25)", +"hsla(0, 62.5%, 75%, 0.25)", "rgba(231, 151, 151, 0.25)", +"hsla(30, 62.5%, 75%, 0.25)", "rgba(231, 191, 151, 0.25)", +"hsla(60, 62.5%, 75%, 0.25)", "rgba(231, 231, 151, 0.25)", +"hsla(90, 62.5%, 75%, 0.25)", "rgba(191, 231, 151, 0.25)", +"hsla(120, 62.5%, 75%, 0.25)", "rgba(151, 231, 151, 0.25)", +"hsla(150, 62.5%, 75%, 0.25)", "rgba(151, 231, 191, 0.25)", +"hsla(180, 62.5%, 75%, 0.25)", "rgba(151, 231, 231, 0.25)", +"hsla(210, 62.5%, 75%, 0.25)", "rgba(151, 191, 231, 0.25)", +"hsla(240, 62.5%, 75%, 0.25)", "rgba(151, 151, 231, 0.25)", +"hsla(270, 62.5%, 75%, 0.25)", "rgba(191, 151, 231, 0.25)", +"hsla(300, 62.5%, 75%, 0.25)", "rgba(231, 151, 231, 0.25)", +"hsla(330, 62.5%, 75%, 0.25)", "rgba(231, 151, 191, 0.25)", +"hsla(0, 75%, 75%, 0.25)", "rgba(239, 143, 143, 0.25)", +"hsla(30, 75%, 75%, 0.25)", "rgba(239, 191, 143, 0.25)", +"hsla(60, 75%, 75%, 0.25)", "rgba(239, 239, 143, 0.25)", +"hsla(90, 75%, 75%, 0.25)", "rgba(191, 239, 143, 0.25)", +"hsla(120, 75%, 75%, 0.25)", "rgba(143, 239, 143, 0.25)", +"hsla(150, 75%, 75%, 0.25)", "rgba(143, 239, 191, 0.25)", +"hsla(180, 75%, 75%, 0.25)", "rgba(143, 239, 239, 0.25)", +"hsla(210, 75%, 75%, 0.25)", "rgba(143, 191, 239, 0.25)", +"hsla(240, 75%, 75%, 0.25)", "rgba(143, 143, 239, 0.25)", +"hsla(270, 75%, 75%, 0.25)", "rgba(191, 143, 239, 0.25)", +"hsla(300, 75%, 75%, 0.25)", "rgba(239, 143, 239, 0.25)", +"hsla(330, 75%, 75%, 0.25)", "rgba(239, 143, 191, 0.25)", +"hsla(0, 87.5%, 75%, 0.25)", "rgba(247, 135, 135, 0.25)", +"hsla(30, 87.5%, 75%, 0.25)", "rgba(247, 191, 135, 0.25)", +"hsla(60, 87.5%, 75%, 0.25)", "rgba(247, 247, 135, 0.25)", +"hsla(90, 87.5%, 75%, 0.25)", "rgba(191, 247, 135, 0.25)", +"hsla(120, 87.5%, 75%, 0.25)", "rgba(135, 247, 135, 0.25)", +"hsla(150, 87.5%, 75%, 0.25)", "rgba(135, 247, 191, 0.25)", +"hsla(180, 87.5%, 75%, 0.25)", "rgba(135, 247, 247, 0.25)", +"hsla(210, 87.5%, 75%, 0.25)", "rgba(135, 191, 247, 0.25)", +"hsla(240, 87.5%, 75%, 0.25)", "rgba(135, 135, 247, 0.25)", +"hsla(270, 87.5%, 75%, 0.25)", "rgba(191, 135, 247, 0.25)", +"hsla(300, 87.5%, 75%, 0.25)", "rgba(247, 135, 247, 0.25)", +"hsla(330, 87.5%, 75%, 0.25)", "rgba(247, 135, 191, 0.25)", +"hsla(0, 100%, 75%, 0.25)", "rgba(255, 128, 128, 0.25)", +"hsla(30, 100%, 75%, 0.25)", "rgba(255, 191, 128, 0.25)", +"hsla(60, 100%, 75%, 0.25)", "rgba(255, 255, 128, 0.25)", +"hsla(90, 100%, 75%, 0.25)", "rgba(191, 255, 128, 0.25)", +"hsla(120, 100%, 75%, 0.25)", "rgba(128, 255, 128, 0.25)", +"hsla(150, 100%, 75%, 0.25)", "rgba(128, 255, 191, 0.25)", +"hsla(180, 100%, 75%, 0.25)", "rgba(128, 255, 255, 0.25)", +"hsla(210, 100%, 75%, 0.25)", "rgba(128, 191, 255, 0.25)", +"hsla(240, 100%, 75%, 0.25)", "rgba(128, 128, 255, 0.25)", +"hsla(270, 100%, 75%, 0.25)", "rgba(191, 128, 255, 0.25)", +"hsla(300, 100%, 75%, 0.25)", "rgba(255, 128, 255, 0.25)", +"hsla(330, 100%, 75%, 0.25)", "rgba(255, 128, 191, 0.25)", +"hsla(0, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(30, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(60, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(90, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(120, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(150, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(180, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(210, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(240, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(270, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(300, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(330, 0%, 87.5%, 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(0, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 219, 0.25)", +"hsla(30, 12.5%, 87.5%, 0.25)", "rgba(227, 223, 219, 0.25)", +"hsla(60, 12.5%, 87.5%, 0.25)", "rgba(227, 227, 219, 0.25)", +"hsla(90, 12.5%, 87.5%, 0.25)", "rgba(223, 227, 219, 0.25)", +"hsla(120, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 219, 0.25)", +"hsla(150, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 223, 0.25)", +"hsla(180, 12.5%, 87.5%, 0.25)", "rgba(219, 227, 227, 0.25)", +"hsla(210, 12.5%, 87.5%, 0.25)", "rgba(219, 223, 227, 0.25)", +"hsla(240, 12.5%, 87.5%, 0.25)", "rgba(219, 219, 227, 0.25)", +"hsla(270, 12.5%, 87.5%, 0.25)", "rgba(223, 219, 227, 0.25)", +"hsla(300, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 227, 0.25)", +"hsla(330, 12.5%, 87.5%, 0.25)", "rgba(227, 219, 223, 0.25)", +"hsla(0, 25%, 87.5%, 0.25)", "rgba(231, 215, 215, 0.25)", +"hsla(30, 25%, 87.5%, 0.25)", "rgba(231, 223, 215, 0.25)", +"hsla(60, 25%, 87.5%, 0.25)", "rgba(231, 231, 215, 0.25)", +"hsla(90, 25%, 87.5%, 0.25)", "rgba(223, 231, 215, 0.25)", +"hsla(120, 25%, 87.5%, 0.25)", "rgba(215, 231, 215, 0.25)", +"hsla(150, 25%, 87.5%, 0.25)", "rgba(215, 231, 223, 0.25)", +"hsla(180, 25%, 87.5%, 0.25)", "rgba(215, 231, 231, 0.25)", +"hsla(210, 25%, 87.5%, 0.25)", "rgba(215, 223, 231, 0.25)", +"hsla(240, 25%, 87.5%, 0.25)", "rgba(215, 215, 231, 0.25)", +"hsla(270, 25%, 87.5%, 0.25)", "rgba(223, 215, 231, 0.25)", +"hsla(300, 25%, 87.5%, 0.25)", "rgba(231, 215, 231, 0.25)", +"hsla(330, 25%, 87.5%, 0.25)", "rgba(231, 215, 223, 0.25)", +"hsla(0, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 211, 0.25)", +"hsla(30, 37.5%, 87.5%, 0.25)", "rgba(235, 223, 211, 0.25)", +"hsla(60, 37.5%, 87.5%, 0.25)", "rgba(235, 235, 211, 0.25)", +"hsla(90, 37.5%, 87.5%, 0.25)", "rgba(223, 235, 211, 0.25)", +"hsla(120, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 211, 0.25)", +"hsla(150, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 223, 0.25)", +"hsla(180, 37.5%, 87.5%, 0.25)", "rgba(211, 235, 235, 0.25)", +"hsla(210, 37.5%, 87.5%, 0.25)", "rgba(211, 223, 235, 0.25)", +"hsla(240, 37.5%, 87.5%, 0.25)", "rgba(211, 211, 235, 0.25)", +"hsla(270, 37.5%, 87.5%, 0.25)", "rgba(223, 211, 235, 0.25)", +"hsla(300, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 235, 0.25)", +"hsla(330, 37.5%, 87.5%, 0.25)", "rgba(235, 211, 223, 0.25)", +"hsla(0, 50%, 87.5%, 0.25)", "rgba(239, 207, 207, 0.25)", +"hsla(30, 50%, 87.5%, 0.25)", "rgba(239, 223, 207, 0.25)", +"hsla(60, 50%, 87.5%, 0.25)", "rgba(239, 239, 207, 0.25)", +"hsla(90, 50%, 87.5%, 0.25)", "rgba(223, 239, 207, 0.25)", +"hsla(120, 50%, 87.5%, 0.25)", "rgba(207, 239, 207, 0.25)", +"hsla(150, 50%, 87.5%, 0.25)", "rgba(207, 239, 223, 0.25)", +"hsla(180, 50%, 87.5%, 0.25)", "rgba(207, 239, 239, 0.25)", +"hsla(210, 50%, 87.5%, 0.25)", "rgba(207, 223, 239, 0.25)", +"hsla(240, 50%, 87.5%, 0.25)", "rgba(207, 207, 239, 0.25)", +"hsla(270, 50%, 87.5%, 0.25)", "rgba(223, 207, 239, 0.25)", +"hsla(300, 50%, 87.5%, 0.25)", "rgba(239, 207, 239, 0.25)", +"hsla(330, 50%, 87.5%, 0.25)", "rgba(239, 207, 223, 0.25)", +"hsla(0, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 203, 0.25)", +"hsla(30, 62.5%, 87.5%, 0.25)", "rgba(243, 223, 203, 0.25)", +"hsla(60, 62.5%, 87.5%, 0.25)", "rgba(243, 243, 203, 0.25)", +"hsla(90, 62.5%, 87.5%, 0.25)", "rgba(223, 243, 203, 0.25)", +"hsla(120, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 203, 0.25)", +"hsla(150, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 223, 0.25)", +"hsla(180, 62.5%, 87.5%, 0.25)", "rgba(203, 243, 243, 0.25)", +"hsla(210, 62.5%, 87.5%, 0.25)", "rgba(203, 223, 243, 0.25)", +"hsla(240, 62.5%, 87.5%, 0.25)", "rgba(203, 203, 243, 0.25)", +"hsla(270, 62.5%, 87.5%, 0.25)", "rgba(223, 203, 243, 0.25)", +"hsla(300, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 243, 0.25)", +"hsla(330, 62.5%, 87.5%, 0.25)", "rgba(243, 203, 223, 0.25)", +"hsla(0, 75%, 87.5%, 0.25)", "rgba(247, 199, 199, 0.25)", +"hsla(30, 75%, 87.5%, 0.25)", "rgba(247, 223, 199, 0.25)", +"hsla(60, 75%, 87.5%, 0.25)", "rgba(247, 247, 199, 0.25)", +"hsla(90, 75%, 87.5%, 0.25)", "rgba(223, 247, 199, 0.25)", +"hsla(120, 75%, 87.5%, 0.25)", "rgba(199, 247, 199, 0.25)", +"hsla(150, 75%, 87.5%, 0.25)", "rgba(199, 247, 223, 0.25)", +"hsla(180, 75%, 87.5%, 0.25)", "rgba(199, 247, 247, 0.25)", +"hsla(210, 75%, 87.5%, 0.25)", "rgba(199, 223, 247, 0.25)", +"hsla(240, 75%, 87.5%, 0.25)", "rgba(199, 199, 247, 0.25)", +"hsla(270, 75%, 87.5%, 0.25)", "rgba(223, 199, 247, 0.25)", +"hsla(300, 75%, 87.5%, 0.25)", "rgba(247, 199, 247, 0.25)", +"hsla(330, 75%, 87.5%, 0.25)", "rgba(247, 199, 223, 0.25)", +"hsla(0, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 195, 0.25)", +"hsla(30, 87.5%, 87.5%, 0.25)", "rgba(251, 223, 195, 0.25)", +"hsla(60, 87.5%, 87.5%, 0.25)", "rgba(251, 251, 195, 0.25)", +"hsla(90, 87.5%, 87.5%, 0.25)", "rgba(223, 251, 195, 0.25)", +"hsla(120, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 195, 0.25)", +"hsla(150, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 223, 0.25)", +"hsla(180, 87.5%, 87.5%, 0.25)", "rgba(195, 251, 251, 0.25)", +"hsla(210, 87.5%, 87.5%, 0.25)", "rgba(195, 223, 251, 0.25)", +"hsla(240, 87.5%, 87.5%, 0.25)", "rgba(195, 195, 251, 0.25)", +"hsla(270, 87.5%, 87.5%, 0.25)", "rgba(223, 195, 251, 0.25)", +"hsla(300, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 251, 0.25)", +"hsla(330, 87.5%, 87.5%, 0.25)", "rgba(251, 195, 223, 0.25)", +"hsla(0, 100%, 87.5%, 0.25)", "rgba(255, 191, 191, 0.25)", +"hsla(30, 100%, 87.5%, 0.25)", "rgba(255, 223, 191, 0.25)", +"hsla(60, 100%, 87.5%, 0.25)", "rgba(255, 255, 191, 0.25)", +"hsla(90, 100%, 87.5%, 0.25)", "rgba(223, 255, 191, 0.25)", +"hsla(120, 100%, 87.5%, 0.25)", "rgba(191, 255, 191, 0.25)", +"hsla(150, 100%, 87.5%, 0.25)", "rgba(191, 255, 223, 0.25)", +"hsla(180, 100%, 87.5%, 0.25)", "rgba(191, 255, 255, 0.25)", +"hsla(210, 100%, 87.5%, 0.25)", "rgba(191, 223, 255, 0.25)", +"hsla(240, 100%, 87.5%, 0.25)", "rgba(191, 191, 255, 0.25)", +"hsla(270, 100%, 87.5%, 0.25)", "rgba(223, 191, 255, 0.25)", +"hsla(300, 100%, 87.5%, 0.25)", "rgba(255, 191, 255, 0.25)", +"hsla(330, 100%, 87.5%, 0.25)", "rgba(255, 191, 223, 0.25)", +"hsla(0, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 0%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 12.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 25%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 37.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 50%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 62.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 75%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 87.5%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330, 100%, 100%, 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 0%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 12.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 25%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 37.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 50%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 62.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 75%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 87.5%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330, 100%, 0%, 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(30, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(60, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(90, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(120, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(150, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(180, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(210, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(240, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(270, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(300, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(330, 0%, 12.5%, 0.0)", "rgba(32, 32, 32, 0)", +"hsla(0, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 28, 0)", +"hsla(30, 12.5%, 12.5%, 0.0)", "rgba(36, 32, 28, 0)", +"hsla(60, 12.5%, 12.5%, 0.0)", "rgba(36, 36, 28, 0)", +"hsla(90, 12.5%, 12.5%, 0.0)", "rgba(32, 36, 28, 0)", +"hsla(120, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 28, 0)", +"hsla(150, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 32, 0)", +"hsla(180, 12.5%, 12.5%, 0.0)", "rgba(28, 36, 36, 0)", +"hsla(210, 12.5%, 12.5%, 0.0)", "rgba(28, 32, 36, 0)", +"hsla(240, 12.5%, 12.5%, 0.0)", "rgba(28, 28, 36, 0)", +"hsla(270, 12.5%, 12.5%, 0.0)", "rgba(32, 28, 36, 0)", +"hsla(300, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 36, 0)", +"hsla(330, 12.5%, 12.5%, 0.0)", "rgba(36, 28, 32, 0)", +"hsla(0, 25%, 12.5%, 0.0)", "rgba(40, 24, 24, 0)", +"hsla(30, 25%, 12.5%, 0.0)", "rgba(40, 32, 24, 0)", +"hsla(60, 25%, 12.5%, 0.0)", "rgba(40, 40, 24, 0)", +"hsla(90, 25%, 12.5%, 0.0)", "rgba(32, 40, 24, 0)", +"hsla(120, 25%, 12.5%, 0.0)", "rgba(24, 40, 24, 0)", +"hsla(150, 25%, 12.5%, 0.0)", "rgba(24, 40, 32, 0)", +"hsla(180, 25%, 12.5%, 0.0)", "rgba(24, 40, 40, 0)", +"hsla(210, 25%, 12.5%, 0.0)", "rgba(24, 32, 40, 0)", +"hsla(240, 25%, 12.5%, 0.0)", "rgba(24, 24, 40, 0)", +"hsla(270, 25%, 12.5%, 0.0)", "rgba(32, 24, 40, 0)", +"hsla(300, 25%, 12.5%, 0.0)", "rgba(40, 24, 40, 0)", +"hsla(330, 25%, 12.5%, 0.0)", "rgba(40, 24, 32, 0)", +"hsla(0, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 20, 0)", +"hsla(30, 37.5%, 12.5%, 0.0)", "rgba(44, 32, 20, 0)", +"hsla(60, 37.5%, 12.5%, 0.0)", "rgba(44, 44, 20, 0)", +"hsla(90, 37.5%, 12.5%, 0.0)", "rgba(32, 44, 20, 0)", +"hsla(120, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 20, 0)", +"hsla(150, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 32, 0)", +"hsla(180, 37.5%, 12.5%, 0.0)", "rgba(20, 44, 44, 0)", +"hsla(210, 37.5%, 12.5%, 0.0)", "rgba(20, 32, 44, 0)", +"hsla(240, 37.5%, 12.5%, 0.0)", "rgba(20, 20, 44, 0)", +"hsla(270, 37.5%, 12.5%, 0.0)", "rgba(32, 20, 44, 0)", +"hsla(300, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 44, 0)", +"hsla(330, 37.5%, 12.5%, 0.0)", "rgba(44, 20, 32, 0)", +"hsla(0, 50%, 12.5%, 0.0)", "rgba(48, 16, 16, 0)", +"hsla(30, 50%, 12.5%, 0.0)", "rgba(48, 32, 16, 0)", +"hsla(60, 50%, 12.5%, 0.0)", "rgba(48, 48, 16, 0)", +"hsla(90, 50%, 12.5%, 0.0)", "rgba(32, 48, 16, 0)", +"hsla(120, 50%, 12.5%, 0.0)", "rgba(16, 48, 16, 0)", +"hsla(150, 50%, 12.5%, 0.0)", "rgba(16, 48, 32, 0)", +"hsla(180, 50%, 12.5%, 0.0)", "rgba(16, 48, 48, 0)", +"hsla(210, 50%, 12.5%, 0.0)", "rgba(16, 32, 48, 0)", +"hsla(240, 50%, 12.5%, 0.0)", "rgba(16, 16, 48, 0)", +"hsla(270, 50%, 12.5%, 0.0)", "rgba(32, 16, 48, 0)", +"hsla(300, 50%, 12.5%, 0.0)", "rgba(48, 16, 48, 0)", +"hsla(330, 50%, 12.5%, 0.0)", "rgba(48, 16, 32, 0)", +"hsla(0, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 12, 0)", +"hsla(30, 62.5%, 12.5%, 0.0)", "rgba(52, 32, 12, 0)", +"hsla(60, 62.5%, 12.5%, 0.0)", "rgba(52, 52, 12, 0)", +"hsla(90, 62.5%, 12.5%, 0.0)", "rgba(32, 52, 12, 0)", +"hsla(120, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 12, 0)", +"hsla(150, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 32, 0)", +"hsla(180, 62.5%, 12.5%, 0.0)", "rgba(12, 52, 52, 0)", +"hsla(210, 62.5%, 12.5%, 0.0)", "rgba(12, 32, 52, 0)", +"hsla(240, 62.5%, 12.5%, 0.0)", "rgba(12, 12, 52, 0)", +"hsla(270, 62.5%, 12.5%, 0.0)", "rgba(32, 12, 52, 0)", +"hsla(300, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 52, 0)", +"hsla(330, 62.5%, 12.5%, 0.0)", "rgba(52, 12, 32, 0)", +"hsla(0, 75%, 12.5%, 0.0)", "rgba(56, 8, 8, 0)", +"hsla(30, 75%, 12.5%, 0.0)", "rgba(56, 32, 8, 0)", +"hsla(60, 75%, 12.5%, 0.0)", "rgba(56, 56, 8, 0)", +"hsla(90, 75%, 12.5%, 0.0)", "rgba(32, 56, 8, 0)", +"hsla(120, 75%, 12.5%, 0.0)", "rgba(8, 56, 8, 0)", +"hsla(150, 75%, 12.5%, 0.0)", "rgba(8, 56, 32, 0)", +"hsla(180, 75%, 12.5%, 0.0)", "rgba(8, 56, 56, 0)", +"hsla(210, 75%, 12.5%, 0.0)", "rgba(8, 32, 56, 0)", +"hsla(240, 75%, 12.5%, 0.0)", "rgba(8, 8, 56, 0)", +"hsla(270, 75%, 12.5%, 0.0)", "rgba(32, 8, 56, 0)", +"hsla(300, 75%, 12.5%, 0.0)", "rgba(56, 8, 56, 0)", +"hsla(330, 75%, 12.5%, 0.0)", "rgba(56, 8, 32, 0)", +"hsla(0, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 4, 0)", +"hsla(30, 87.5%, 12.5%, 0.0)", "rgba(60, 32, 4, 0)", +"hsla(60, 87.5%, 12.5%, 0.0)", "rgba(60, 60, 4, 0)", +"hsla(90, 87.5%, 12.5%, 0.0)", "rgba(32, 60, 4, 0)", +"hsla(120, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 4, 0)", +"hsla(150, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 32, 0)", +"hsla(180, 87.5%, 12.5%, 0.0)", "rgba(4, 60, 60, 0)", +"hsla(210, 87.5%, 12.5%, 0.0)", "rgba(4, 32, 60, 0)", +"hsla(240, 87.5%, 12.5%, 0.0)", "rgba(4, 4, 60, 0)", +"hsla(270, 87.5%, 12.5%, 0.0)", "rgba(32, 4, 60, 0)", +"hsla(300, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 60, 0)", +"hsla(330, 87.5%, 12.5%, 0.0)", "rgba(60, 4, 32, 0)", +"hsla(0, 100%, 12.5%, 0.0)", "rgba(64, 0, 0, 0)", +"hsla(30, 100%, 12.5%, 0.0)", "rgba(64, 32, 0, 0)", +"hsla(60, 100%, 12.5%, 0.0)", "rgba(64, 64, 0, 0)", +"hsla(90, 100%, 12.5%, 0.0)", "rgba(32, 64, 0, 0)", +"hsla(120, 100%, 12.5%, 0.0)", "rgba(0, 64, 0, 0)", +"hsla(150, 100%, 12.5%, 0.0)", "rgba(0, 64, 32, 0)", +"hsla(180, 100%, 12.5%, 0.0)", "rgba(0, 64, 64, 0)", +"hsla(210, 100%, 12.5%, 0.0)", "rgba(0, 32, 64, 0)", +"hsla(240, 100%, 12.5%, 0.0)", "rgba(0, 0, 64, 0)", +"hsla(270, 100%, 12.5%, 0.0)", "rgba(32, 0, 64, 0)", +"hsla(300, 100%, 12.5%, 0.0)", "rgba(64, 0, 64, 0)", +"hsla(330, 100%, 12.5%, 0.0)", "rgba(64, 0, 32, 0)", +"hsla(0, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(30, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(60, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(90, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(120, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(150, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(180, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(210, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(240, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(270, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(300, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(330, 0%, 25%, 0.0)", "rgba(64, 64, 64, 0)", +"hsla(0, 12.5%, 25%, 0.0)", "rgba(72, 56, 56, 0)", +"hsla(30, 12.5%, 25%, 0.0)", "rgba(72, 64, 56, 0)", +"hsla(60, 12.5%, 25%, 0.0)", "rgba(72, 72, 56, 0)", +"hsla(90, 12.5%, 25%, 0.0)", "rgba(64, 72, 56, 0)", +"hsla(120, 12.5%, 25%, 0.0)", "rgba(56, 72, 56, 0)", +"hsla(150, 12.5%, 25%, 0.0)", "rgba(56, 72, 64, 0)", +"hsla(180, 12.5%, 25%, 0.0)", "rgba(56, 72, 72, 0)", +"hsla(210, 12.5%, 25%, 0.0)", "rgba(56, 64, 72, 0)", +"hsla(240, 12.5%, 25%, 0.0)", "rgba(56, 56, 72, 0)", +"hsla(270, 12.5%, 25%, 0.0)", "rgba(64, 56, 72, 0)", +"hsla(300, 12.5%, 25%, 0.0)", "rgba(72, 56, 72, 0)", +"hsla(330, 12.5%, 25%, 0.0)", "rgba(72, 56, 64, 0)", +"hsla(0, 25%, 25%, 0.0)", "rgba(80, 48, 48, 0)", +"hsla(30, 25%, 25%, 0.0)", "rgba(80, 64, 48, 0)", +"hsla(60, 25%, 25%, 0.0)", "rgba(80, 80, 48, 0)", +"hsla(90, 25%, 25%, 0.0)", "rgba(64, 80, 48, 0)", +"hsla(120, 25%, 25%, 0.0)", "rgba(48, 80, 48, 0)", +"hsla(150, 25%, 25%, 0.0)", "rgba(48, 80, 64, 0)", +"hsla(180, 25%, 25%, 0.0)", "rgba(48, 80, 80, 0)", +"hsla(210, 25%, 25%, 0.0)", "rgba(48, 64, 80, 0)", +"hsla(240, 25%, 25%, 0.0)", "rgba(48, 48, 80, 0)", +"hsla(270, 25%, 25%, 0.0)", "rgba(64, 48, 80, 0)", +"hsla(300, 25%, 25%, 0.0)", "rgba(80, 48, 80, 0)", +"hsla(330, 25%, 25%, 0.0)", "rgba(80, 48, 64, 0)", +"hsla(0, 37.5%, 25%, 0.0)", "rgba(88, 40, 40, 0)", +"hsla(30, 37.5%, 25%, 0.0)", "rgba(88, 64, 40, 0)", +"hsla(60, 37.5%, 25%, 0.0)", "rgba(88, 88, 40, 0)", +"hsla(90, 37.5%, 25%, 0.0)", "rgba(64, 88, 40, 0)", +"hsla(120, 37.5%, 25%, 0.0)", "rgba(40, 88, 40, 0)", +"hsla(150, 37.5%, 25%, 0.0)", "rgba(40, 88, 64, 0)", +"hsla(180, 37.5%, 25%, 0.0)", "rgba(40, 88, 88, 0)", +"hsla(210, 37.5%, 25%, 0.0)", "rgba(40, 64, 88, 0)", +"hsla(240, 37.5%, 25%, 0.0)", "rgba(40, 40, 88, 0)", +"hsla(270, 37.5%, 25%, 0.0)", "rgba(64, 40, 88, 0)", +"hsla(300, 37.5%, 25%, 0.0)", "rgba(88, 40, 88, 0)", +"hsla(330, 37.5%, 25%, 0.0)", "rgba(88, 40, 64, 0)", +"hsla(0, 50%, 25%, 0.0)", "rgba(96, 32, 32, 0)", +"hsla(30, 50%, 25%, 0.0)", "rgba(96, 64, 32, 0)", +"hsla(60, 50%, 25%, 0.0)", "rgba(96, 96, 32, 0)", +"hsla(90, 50%, 25%, 0.0)", "rgba(64, 96, 32, 0)", +"hsla(120, 50%, 25%, 0.0)", "rgba(32, 96, 32, 0)", +"hsla(150, 50%, 25%, 0.0)", "rgba(32, 96, 64, 0)", +"hsla(180, 50%, 25%, 0.0)", "rgba(32, 96, 96, 0)", +"hsla(210, 50%, 25%, 0.0)", "rgba(32, 64, 96, 0)", +"hsla(240, 50%, 25%, 0.0)", "rgba(32, 32, 96, 0)", +"hsla(270, 50%, 25%, 0.0)", "rgba(64, 32, 96, 0)", +"hsla(300, 50%, 25%, 0.0)", "rgba(96, 32, 96, 0)", +"hsla(330, 50%, 25%, 0.0)", "rgba(96, 32, 64, 0)", +"hsla(0, 62.5%, 25%, 0.0)", "rgba(104, 24, 24, 0)", +"hsla(30, 62.5%, 25%, 0.0)", "rgba(104, 64, 24, 0)", +"hsla(60, 62.5%, 25%, 0.0)", "rgba(104, 104, 24, 0)", +"hsla(90, 62.5%, 25%, 0.0)", "rgba(64, 104, 24, 0)", +"hsla(120, 62.5%, 25%, 0.0)", "rgba(24, 104, 24, 0)", +"hsla(150, 62.5%, 25%, 0.0)", "rgba(24, 104, 64, 0)", +"hsla(180, 62.5%, 25%, 0.0)", "rgba(24, 104, 104, 0)", +"hsla(210, 62.5%, 25%, 0.0)", "rgba(24, 64, 104, 0)", +"hsla(240, 62.5%, 25%, 0.0)", "rgba(24, 24, 104, 0)", +"hsla(270, 62.5%, 25%, 0.0)", "rgba(64, 24, 104, 0)", +"hsla(300, 62.5%, 25%, 0.0)", "rgba(104, 24, 104, 0)", +"hsla(330, 62.5%, 25%, 0.0)", "rgba(104, 24, 64, 0)", +"hsla(0, 75%, 25%, 0.0)", "rgba(112, 16, 16, 0)", +"hsla(30, 75%, 25%, 0.0)", "rgba(112, 64, 16, 0)", +"hsla(60, 75%, 25%, 0.0)", "rgba(112, 112, 16, 0)", +"hsla(90, 75%, 25%, 0.0)", "rgba(64, 112, 16, 0)", +"hsla(120, 75%, 25%, 0.0)", "rgba(16, 112, 16, 0)", +"hsla(150, 75%, 25%, 0.0)", "rgba(16, 112, 64, 0)", +"hsla(180, 75%, 25%, 0.0)", "rgba(16, 112, 112, 0)", +"hsla(210, 75%, 25%, 0.0)", "rgba(16, 64, 112, 0)", +"hsla(240, 75%, 25%, 0.0)", "rgba(16, 16, 112, 0)", +"hsla(270, 75%, 25%, 0.0)", "rgba(64, 16, 112, 0)", +"hsla(300, 75%, 25%, 0.0)", "rgba(112, 16, 112, 0)", +"hsla(330, 75%, 25%, 0.0)", "rgba(112, 16, 64, 0)", +"hsla(0, 87.5%, 25%, 0.0)", "rgba(120, 8, 8, 0)", +"hsla(30, 87.5%, 25%, 0.0)", "rgba(120, 64, 8, 0)", +"hsla(60, 87.5%, 25%, 0.0)", "rgba(120, 120, 8, 0)", +"hsla(90, 87.5%, 25%, 0.0)", "rgba(64, 120, 8, 0)", +"hsla(120, 87.5%, 25%, 0.0)", "rgba(8, 120, 8, 0)", +"hsla(150, 87.5%, 25%, 0.0)", "rgba(8, 120, 64, 0)", +"hsla(180, 87.5%, 25%, 0.0)", "rgba(8, 120, 120, 0)", +"hsla(210, 87.5%, 25%, 0.0)", "rgba(8, 64, 120, 0)", +"hsla(240, 87.5%, 25%, 0.0)", "rgba(8, 8, 120, 0)", +"hsla(270, 87.5%, 25%, 0.0)", "rgba(64, 8, 120, 0)", +"hsla(300, 87.5%, 25%, 0.0)", "rgba(120, 8, 120, 0)", +"hsla(330, 87.5%, 25%, 0.0)", "rgba(120, 8, 64, 0)", +"hsla(0, 100%, 25%, 0.0)", "rgba(128, 0, 0, 0)", +"hsla(30, 100%, 25%, 0.0)", "rgba(128, 64, 0, 0)", +"hsla(60, 100%, 25%, 0.0)", "rgba(128, 128, 0, 0)", +"hsla(90, 100%, 25%, 0.0)", "rgba(64, 128, 0, 0)", +"hsla(120, 100%, 25%, 0.0)", "rgba(0, 128, 0, 0)", +"hsla(150, 100%, 25%, 0.0)", "rgba(0, 128, 64, 0)", +"hsla(180, 100%, 25%, 0.0)", "rgba(0, 128, 128, 0)", +"hsla(210, 100%, 25%, 0.0)", "rgba(0, 64, 128, 0)", +"hsla(240, 100%, 25%, 0.0)", "rgba(0, 0, 128, 0)", +"hsla(270, 100%, 25%, 0.0)", "rgba(64, 0, 128, 0)", +"hsla(300, 100%, 25%, 0.0)", "rgba(128, 0, 128, 0)", +"hsla(330, 100%, 25%, 0.0)", "rgba(128, 0, 64, 0)", +"hsla(0, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(30, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(60, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(90, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(120, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(150, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(180, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(210, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(240, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(270, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(300, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(330, 0%, 37.5%, 0.0)", "rgba(96, 96, 96, 0)", +"hsla(0, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 84, 0)", +"hsla(30, 12.5%, 37.5%, 0.0)", "rgba(108, 96, 84, 0)", +"hsla(60, 12.5%, 37.5%, 0.0)", "rgba(108, 108, 84, 0)", +"hsla(90, 12.5%, 37.5%, 0.0)", "rgba(96, 108, 84, 0)", +"hsla(120, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 84, 0)", +"hsla(150, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 96, 0)", +"hsla(180, 12.5%, 37.5%, 0.0)", "rgba(84, 108, 108, 0)", +"hsla(210, 12.5%, 37.5%, 0.0)", "rgba(84, 96, 108, 0)", +"hsla(240, 12.5%, 37.5%, 0.0)", "rgba(84, 84, 108, 0)", +"hsla(270, 12.5%, 37.5%, 0.0)", "rgba(96, 84, 108, 0)", +"hsla(300, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 108, 0)", +"hsla(330, 12.5%, 37.5%, 0.0)", "rgba(108, 84, 96, 0)", +"hsla(0, 25%, 37.5%, 0.0)", "rgba(120, 72, 72, 0)", +"hsla(30, 25%, 37.5%, 0.0)", "rgba(120, 96, 72, 0)", +"hsla(60, 25%, 37.5%, 0.0)", "rgba(120, 120, 72, 0)", +"hsla(90, 25%, 37.5%, 0.0)", "rgba(96, 120, 72, 0)", +"hsla(120, 25%, 37.5%, 0.0)", "rgba(72, 120, 72, 0)", +"hsla(150, 25%, 37.5%, 0.0)", "rgba(72, 120, 96, 0)", +"hsla(180, 25%, 37.5%, 0.0)", "rgba(72, 120, 120, 0)", +"hsla(210, 25%, 37.5%, 0.0)", "rgba(72, 96, 120, 0)", +"hsla(240, 25%, 37.5%, 0.0)", "rgba(72, 72, 120, 0)", +"hsla(270, 25%, 37.5%, 0.0)", "rgba(96, 72, 120, 0)", +"hsla(300, 25%, 37.5%, 0.0)", "rgba(120, 72, 120, 0)", +"hsla(330, 25%, 37.5%, 0.0)", "rgba(120, 72, 96, 0)", +"hsla(0, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 60, 0)", +"hsla(30, 37.5%, 37.5%, 0.0)", "rgba(131, 96, 60, 0)", +"hsla(60, 37.5%, 37.5%, 0.0)", "rgba(131, 131, 60, 0)", +"hsla(90, 37.5%, 37.5%, 0.0)", "rgba(96, 131, 60, 0)", +"hsla(120, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 60, 0)", +"hsla(150, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 96, 0)", +"hsla(180, 37.5%, 37.5%, 0.0)", "rgba(60, 131, 131, 0)", +"hsla(210, 37.5%, 37.5%, 0.0)", "rgba(60, 96, 131, 0)", +"hsla(240, 37.5%, 37.5%, 0.0)", "rgba(60, 60, 131, 0)", +"hsla(270, 37.5%, 37.5%, 0.0)", "rgba(96, 60, 131, 0)", +"hsla(300, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 131, 0)", +"hsla(330, 37.5%, 37.5%, 0.0)", "rgba(131, 60, 96, 0)", +"hsla(0, 50%, 37.5%, 0.0)", "rgba(143, 48, 48, 0)", +"hsla(30, 50%, 37.5%, 0.0)", "rgba(143, 96, 48, 0)", +"hsla(60, 50%, 37.5%, 0.0)", "rgba(143, 143, 48, 0)", +"hsla(90, 50%, 37.5%, 0.0)", "rgba(96, 143, 48, 0)", +"hsla(120, 50%, 37.5%, 0.0)", "rgba(48, 143, 48, 0)", +"hsla(150, 50%, 37.5%, 0.0)", "rgba(48, 143, 96, 0)", +"hsla(180, 50%, 37.5%, 0.0)", "rgba(48, 143, 143, 0)", +"hsla(210, 50%, 37.5%, 0.0)", "rgba(48, 96, 143, 0)", +"hsla(240, 50%, 37.5%, 0.0)", "rgba(48, 48, 143, 0)", +"hsla(270, 50%, 37.5%, 0.0)", "rgba(96, 48, 143, 0)", +"hsla(300, 50%, 37.5%, 0.0)", "rgba(143, 48, 143, 0)", +"hsla(330, 50%, 37.5%, 0.0)", "rgba(143, 48, 96, 0)", +"hsla(0, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 36, 0)", +"hsla(30, 62.5%, 37.5%, 0.0)", "rgba(155, 96, 36, 0)", +"hsla(60, 62.5%, 37.5%, 0.0)", "rgba(155, 155, 36, 0)", +"hsla(90, 62.5%, 37.5%, 0.0)", "rgba(96, 155, 36, 0)", +"hsla(120, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 36, 0)", +"hsla(150, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 96, 0)", +"hsla(180, 62.5%, 37.5%, 0.0)", "rgba(36, 155, 155, 0)", +"hsla(210, 62.5%, 37.5%, 0.0)", "rgba(36, 96, 155, 0)", +"hsla(240, 62.5%, 37.5%, 0.0)", "rgba(36, 36, 155, 0)", +"hsla(270, 62.5%, 37.5%, 0.0)", "rgba(96, 36, 155, 0)", +"hsla(300, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 155, 0)", +"hsla(330, 62.5%, 37.5%, 0.0)", "rgba(155, 36, 96, 0)", +"hsla(0, 75%, 37.5%, 0.0)", "rgba(167, 24, 24, 0)", +"hsla(30, 75%, 37.5%, 0.0)", "rgba(167, 96, 24, 0)", +"hsla(60, 75%, 37.5%, 0.0)", "rgba(167, 167, 24, 0)", +"hsla(90, 75%, 37.5%, 0.0)", "rgba(96, 167, 24, 0)", +"hsla(120, 75%, 37.5%, 0.0)", "rgba(24, 167, 24, 0)", +"hsla(150, 75%, 37.5%, 0.0)", "rgba(24, 167, 96, 0)", +"hsla(180, 75%, 37.5%, 0.0)", "rgba(24, 167, 167, 0)", +"hsla(210, 75%, 37.5%, 0.0)", "rgba(24, 96, 167, 0)", +"hsla(240, 75%, 37.5%, 0.0)", "rgba(24, 24, 167, 0)", +"hsla(270, 75%, 37.5%, 0.0)", "rgba(96, 24, 167, 0)", +"hsla(300, 75%, 37.5%, 0.0)", "rgba(167, 24, 167, 0)", +"hsla(330, 75%, 37.5%, 0.0)", "rgba(167, 24, 96, 0)", +"hsla(0, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 12, 0)", +"hsla(30, 87.5%, 37.5%, 0.0)", "rgba(179, 96, 12, 0)", +"hsla(60, 87.5%, 37.5%, 0.0)", "rgba(179, 179, 12, 0)", +"hsla(90, 87.5%, 37.5%, 0.0)", "rgba(96, 179, 12, 0)", +"hsla(120, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 12, 0)", +"hsla(150, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 96, 0)", +"hsla(180, 87.5%, 37.5%, 0.0)", "rgba(12, 179, 179, 0)", +"hsla(210, 87.5%, 37.5%, 0.0)", "rgba(12, 96, 179, 0)", +"hsla(240, 87.5%, 37.5%, 0.0)", "rgba(12, 12, 179, 0)", +"hsla(270, 87.5%, 37.5%, 0.0)", "rgba(96, 12, 179, 0)", +"hsla(300, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 179, 0)", +"hsla(330, 87.5%, 37.5%, 0.0)", "rgba(179, 12, 96, 0)", +"hsla(0, 100%, 37.5%, 0.0)", "rgba(191, 0, 0, 0)", +"hsla(30, 100%, 37.5%, 0.0)", "rgba(191, 96, 0, 0)", +"hsla(60, 100%, 37.5%, 0.0)", "rgba(191, 191, 0, 0)", +"hsla(90, 100%, 37.5%, 0.0)", "rgba(96, 191, 0, 0)", +"hsla(120, 100%, 37.5%, 0.0)", "rgba(0, 191, 0, 0)", +"hsla(150, 100%, 37.5%, 0.0)", "rgba(0, 191, 96, 0)", +"hsla(180, 100%, 37.5%, 0.0)", "rgba(0, 191, 191, 0)", +"hsla(210, 100%, 37.5%, 0.0)", "rgba(0, 96, 191, 0)", +"hsla(240, 100%, 37.5%, 0.0)", "rgba(0, 0, 191, 0)", +"hsla(270, 100%, 37.5%, 0.0)", "rgba(96, 0, 191, 0)", +"hsla(300, 100%, 37.5%, 0.0)", "rgba(191, 0, 191, 0)", +"hsla(330, 100%, 37.5%, 0.0)", "rgba(191, 0, 96, 0)", +"hsla(0, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(30, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(60, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(90, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(120, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(150, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(180, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(210, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(240, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(270, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(300, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(330, 0%, 50%, 0.0)", "rgba(128, 128, 128, 0)", +"hsla(0, 12.5%, 50%, 0.0)", "rgba(143, 112, 112, 0)", +"hsla(30, 12.5%, 50%, 0.0)", "rgba(143, 128, 112, 0)", +"hsla(60, 12.5%, 50%, 0.0)", "rgba(143, 143, 112, 0)", +"hsla(90, 12.5%, 50%, 0.0)", "rgba(128, 143, 112, 0)", +"hsla(120, 12.5%, 50%, 0.0)", "rgba(112, 143, 112, 0)", +"hsla(150, 12.5%, 50%, 0.0)", "rgba(112, 143, 128, 0)", +"hsla(180, 12.5%, 50%, 0.0)", "rgba(112, 143, 143, 0)", +"hsla(210, 12.5%, 50%, 0.0)", "rgba(112, 128, 143, 0)", +"hsla(240, 12.5%, 50%, 0.0)", "rgba(112, 112, 143, 0)", +"hsla(270, 12.5%, 50%, 0.0)", "rgba(128, 112, 143, 0)", +"hsla(300, 12.5%, 50%, 0.0)", "rgba(143, 112, 143, 0)", +"hsla(330, 12.5%, 50%, 0.0)", "rgba(143, 112, 128, 0)", +"hsla(0, 25%, 50%, 0.0)", "rgba(159, 96, 96, 0)", +"hsla(30, 25%, 50%, 0.0)", "rgba(159, 128, 96, 0)", +"hsla(60, 25%, 50%, 0.0)", "rgba(159, 159, 96, 0)", +"hsla(90, 25%, 50%, 0.0)", "rgba(128, 159, 96, 0)", +"hsla(120, 25%, 50%, 0.0)", "rgba(96, 159, 96, 0)", +"hsla(150, 25%, 50%, 0.0)", "rgba(96, 159, 128, 0)", +"hsla(180, 25%, 50%, 0.0)", "rgba(96, 159, 159, 0)", +"hsla(210, 25%, 50%, 0.0)", "rgba(96, 128, 159, 0)", +"hsla(240, 25%, 50%, 0.0)", "rgba(96, 96, 159, 0)", +"hsla(270, 25%, 50%, 0.0)", "rgba(128, 96, 159, 0)", +"hsla(300, 25%, 50%, 0.0)", "rgba(159, 96, 159, 0)", +"hsla(330, 25%, 50%, 0.0)", "rgba(159, 96, 128, 0)", +"hsla(0, 37.5%, 50%, 0.0)", "rgba(175, 80, 80, 0)", +"hsla(30, 37.5%, 50%, 0.0)", "rgba(175, 128, 80, 0)", +"hsla(60, 37.5%, 50%, 0.0)", "rgba(175, 175, 80, 0)", +"hsla(90, 37.5%, 50%, 0.0)", "rgba(128, 175, 80, 0)", +"hsla(120, 37.5%, 50%, 0.0)", "rgba(80, 175, 80, 0)", +"hsla(150, 37.5%, 50%, 0.0)", "rgba(80, 175, 128, 0)", +"hsla(180, 37.5%, 50%, 0.0)", "rgba(80, 175, 175, 0)", +"hsla(210, 37.5%, 50%, 0.0)", "rgba(80, 128, 175, 0)", +"hsla(240, 37.5%, 50%, 0.0)", "rgba(80, 80, 175, 0)", +"hsla(270, 37.5%, 50%, 0.0)", "rgba(128, 80, 175, 0)", +"hsla(300, 37.5%, 50%, 0.0)", "rgba(175, 80, 175, 0)", +"hsla(330, 37.5%, 50%, 0.0)", "rgba(175, 80, 128, 0)", +"hsla(0, 50%, 50%, 0.0)", "rgba(191, 64, 64, 0)", +"hsla(30, 50%, 50%, 0.0)", "rgba(191, 128, 64, 0)", +"hsla(60, 50%, 50%, 0.0)", "rgba(191, 191, 64, 0)", +"hsla(90, 50%, 50%, 0.0)", "rgba(128, 191, 64, 0)", +"hsla(120, 50%, 50%, 0.0)", "rgba(64, 191, 64, 0)", +"hsla(150, 50%, 50%, 0.0)", "rgba(64, 191, 128, 0)", +"hsla(180, 50%, 50%, 0.0)", "rgba(64, 191, 191, 0)", +"hsla(210, 50%, 50%, 0.0)", "rgba(64, 128, 191, 0)", +"hsla(240, 50%, 50%, 0.0)", "rgba(64, 64, 191, 0)", +"hsla(270, 50%, 50%, 0.0)", "rgba(128, 64, 191, 0)", +"hsla(300, 50%, 50%, 0.0)", "rgba(191, 64, 191, 0)", +"hsla(330, 50%, 50%, 0.0)", "rgba(191, 64, 128, 0)", +"hsla(0, 62.5%, 50%, 0.0)", "rgba(207, 48, 48, 0)", +"hsla(30, 62.5%, 50%, 0.0)", "rgba(207, 128, 48, 0)", +"hsla(60, 62.5%, 50%, 0.0)", "rgba(207, 207, 48, 0)", +"hsla(90, 62.5%, 50%, 0.0)", "rgba(128, 207, 48, 0)", +"hsla(120, 62.5%, 50%, 0.0)", "rgba(48, 207, 48, 0)", +"hsla(150, 62.5%, 50%, 0.0)", "rgba(48, 207, 128, 0)", +"hsla(180, 62.5%, 50%, 0.0)", "rgba(48, 207, 207, 0)", +"hsla(210, 62.5%, 50%, 0.0)", "rgba(48, 128, 207, 0)", +"hsla(240, 62.5%, 50%, 0.0)", "rgba(48, 48, 207, 0)", +"hsla(270, 62.5%, 50%, 0.0)", "rgba(128, 48, 207, 0)", +"hsla(300, 62.5%, 50%, 0.0)", "rgba(207, 48, 207, 0)", +"hsla(330, 62.5%, 50%, 0.0)", "rgba(207, 48, 128, 0)", +"hsla(0, 75%, 50%, 0.0)", "rgba(223, 32, 32, 0)", +"hsla(30, 75%, 50%, 0.0)", "rgba(223, 128, 32, 0)", +"hsla(60, 75%, 50%, 0.0)", "rgba(223, 223, 32, 0)", +"hsla(90, 75%, 50%, 0.0)", "rgba(128, 223, 32, 0)", +"hsla(120, 75%, 50%, 0.0)", "rgba(32, 223, 32, 0)", +"hsla(150, 75%, 50%, 0.0)", "rgba(32, 223, 128, 0)", +"hsla(180, 75%, 50%, 0.0)", "rgba(32, 223, 223, 0)", +"hsla(210, 75%, 50%, 0.0)", "rgba(32, 128, 223, 0)", +"hsla(240, 75%, 50%, 0.0)", "rgba(32, 32, 223, 0)", +"hsla(270, 75%, 50%, 0.0)", "rgba(128, 32, 223, 0)", +"hsla(300, 75%, 50%, 0.0)", "rgba(223, 32, 223, 0)", +"hsla(330, 75%, 50%, 0.0)", "rgba(223, 32, 128, 0)", +"hsla(0, 87.5%, 50%, 0.0)", "rgba(239, 16, 16, 0)", +"hsla(30, 87.5%, 50%, 0.0)", "rgba(239, 128, 16, 0)", +"hsla(60, 87.5%, 50%, 0.0)", "rgba(239, 239, 16, 0)", +"hsla(90, 87.5%, 50%, 0.0)", "rgba(128, 239, 16, 0)", +"hsla(120, 87.5%, 50%, 0.0)", "rgba(16, 239, 16, 0)", +"hsla(150, 87.5%, 50%, 0.0)", "rgba(16, 239, 128, 0)", +"hsla(180, 87.5%, 50%, 0.0)", "rgba(16, 239, 239, 0)", +"hsla(210, 87.5%, 50%, 0.0)", "rgba(16, 128, 239, 0)", +"hsla(240, 87.5%, 50%, 0.0)", "rgba(16, 16, 239, 0)", +"hsla(270, 87.5%, 50%, 0.0)", "rgba(128, 16, 239, 0)", +"hsla(300, 87.5%, 50%, 0.0)", "rgba(239, 16, 239, 0)", +"hsla(330, 87.5%, 50%, 0.0)", "rgba(239, 16, 128, 0)", +"hsla(0, 100%, 50%, 0.0)", "rgba(255, 0, 0, 0)", +"hsla(30, 100%, 50%, 0.0)", "rgba(255, 128, 0, 0)", +"hsla(60, 100%, 50%, 0.0)", "rgba(255, 255, 0, 0)", +"hsla(90, 100%, 50%, 0.0)", "rgba(128, 255, 0, 0)", +"hsla(120, 100%, 50%, 0.0)", "rgba(0, 255, 0, 0)", +"hsla(150, 100%, 50%, 0.0)", "rgba(0, 255, 128, 0)", +"hsla(180, 100%, 50%, 0.0)", "rgba(0, 255, 255, 0)", +"hsla(210, 100%, 50%, 0.0)", "rgba(0, 128, 255, 0)", +"hsla(240, 100%, 50%, 0.0)", "rgba(0, 0, 255, 0)", +"hsla(270, 100%, 50%, 0.0)", "rgba(128, 0, 255, 0)", +"hsla(300, 100%, 50%, 0.0)", "rgba(255, 0, 255, 0)", +"hsla(330, 100%, 50%, 0.0)", "rgba(255, 0, 128, 0)", +"hsla(0, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(30, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(60, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(90, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(120, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(150, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(180, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(210, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(240, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(270, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(300, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(330, 0%, 62.5%, 0.0)", "rgba(159, 159, 159, 0)", +"hsla(0, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 147, 0)", +"hsla(30, 12.5%, 62.5%, 0.0)", "rgba(171, 159, 147, 0)", +"hsla(60, 12.5%, 62.5%, 0.0)", "rgba(171, 171, 147, 0)", +"hsla(90, 12.5%, 62.5%, 0.0)", "rgba(159, 171, 147, 0)", +"hsla(120, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 147, 0)", +"hsla(150, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 159, 0)", +"hsla(180, 12.5%, 62.5%, 0.0)", "rgba(147, 171, 171, 0)", +"hsla(210, 12.5%, 62.5%, 0.0)", "rgba(147, 159, 171, 0)", +"hsla(240, 12.5%, 62.5%, 0.0)", "rgba(147, 147, 171, 0)", +"hsla(270, 12.5%, 62.5%, 0.0)", "rgba(159, 147, 171, 0)", +"hsla(300, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 171, 0)", +"hsla(330, 12.5%, 62.5%, 0.0)", "rgba(171, 147, 159, 0)", +"hsla(0, 25%, 62.5%, 0.0)", "rgba(183, 135, 135, 0)", +"hsla(30, 25%, 62.5%, 0.0)", "rgba(183, 159, 135, 0)", +"hsla(60, 25%, 62.5%, 0.0)", "rgba(183, 183, 135, 0)", +"hsla(90, 25%, 62.5%, 0.0)", "rgba(159, 183, 135, 0)", +"hsla(120, 25%, 62.5%, 0.0)", "rgba(135, 183, 135, 0)", +"hsla(150, 25%, 62.5%, 0.0)", "rgba(135, 183, 159, 0)", +"hsla(180, 25%, 62.5%, 0.0)", "rgba(135, 183, 183, 0)", +"hsla(210, 25%, 62.5%, 0.0)", "rgba(135, 159, 183, 0)", +"hsla(240, 25%, 62.5%, 0.0)", "rgba(135, 135, 183, 0)", +"hsla(270, 25%, 62.5%, 0.0)", "rgba(159, 135, 183, 0)", +"hsla(300, 25%, 62.5%, 0.0)", "rgba(183, 135, 183, 0)", +"hsla(330, 25%, 62.5%, 0.0)", "rgba(183, 135, 159, 0)", +"hsla(0, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 124, 0)", +"hsla(30, 37.5%, 62.5%, 0.0)", "rgba(195, 159, 124, 0)", +"hsla(60, 37.5%, 62.5%, 0.0)", "rgba(195, 195, 124, 0)", +"hsla(90, 37.5%, 62.5%, 0.0)", "rgba(159, 195, 124, 0)", +"hsla(120, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 124, 0)", +"hsla(150, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 159, 0)", +"hsla(180, 37.5%, 62.5%, 0.0)", "rgba(124, 195, 195, 0)", +"hsla(210, 37.5%, 62.5%, 0.0)", "rgba(124, 159, 195, 0)", +"hsla(240, 37.5%, 62.5%, 0.0)", "rgba(124, 124, 195, 0)", +"hsla(270, 37.5%, 62.5%, 0.0)", "rgba(159, 124, 195, 0)", +"hsla(300, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 195, 0)", +"hsla(330, 37.5%, 62.5%, 0.0)", "rgba(195, 124, 159, 0)", +"hsla(0, 50%, 62.5%, 0.0)", "rgba(207, 112, 112, 0)", +"hsla(30, 50%, 62.5%, 0.0)", "rgba(207, 159, 112, 0)", +"hsla(60, 50%, 62.5%, 0.0)", "rgba(207, 207, 112, 0)", +"hsla(90, 50%, 62.5%, 0.0)", "rgba(159, 207, 112, 0)", +"hsla(120, 50%, 62.5%, 0.0)", "rgba(112, 207, 112, 0)", +"hsla(150, 50%, 62.5%, 0.0)", "rgba(112, 207, 159, 0)", +"hsla(180, 50%, 62.5%, 0.0)", "rgba(112, 207, 207, 0)", +"hsla(210, 50%, 62.5%, 0.0)", "rgba(112, 159, 207, 0)", +"hsla(240, 50%, 62.5%, 0.0)", "rgba(112, 112, 207, 0)", +"hsla(270, 50%, 62.5%, 0.0)", "rgba(159, 112, 207, 0)", +"hsla(300, 50%, 62.5%, 0.0)", "rgba(207, 112, 207, 0)", +"hsla(330, 50%, 62.5%, 0.0)", "rgba(207, 112, 159, 0)", +"hsla(0, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 100, 0)", +"hsla(30, 62.5%, 62.5%, 0.0)", "rgba(219, 159, 100, 0)", +"hsla(60, 62.5%, 62.5%, 0.0)", "rgba(219, 219, 100, 0)", +"hsla(90, 62.5%, 62.5%, 0.0)", "rgba(159, 219, 100, 0)", +"hsla(120, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 100, 0)", +"hsla(150, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 159, 0)", +"hsla(180, 62.5%, 62.5%, 0.0)", "rgba(100, 219, 219, 0)", +"hsla(210, 62.5%, 62.5%, 0.0)", "rgba(100, 159, 219, 0)", +"hsla(240, 62.5%, 62.5%, 0.0)", "rgba(100, 100, 219, 0)", +"hsla(270, 62.5%, 62.5%, 0.0)", "rgba(159, 100, 219, 0)", +"hsla(300, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 219, 0)", +"hsla(330, 62.5%, 62.5%, 0.0)", "rgba(219, 100, 159, 0)", +"hsla(0, 75%, 62.5%, 0.0)", "rgba(231, 88, 88, 0)", +"hsla(30, 75%, 62.5%, 0.0)", "rgba(231, 159, 88, 0)", +"hsla(60, 75%, 62.5%, 0.0)", "rgba(231, 231, 88, 0)", +"hsla(90, 75%, 62.5%, 0.0)", "rgba(159, 231, 88, 0)", +"hsla(120, 75%, 62.5%, 0.0)", "rgba(88, 231, 88, 0)", +"hsla(150, 75%, 62.5%, 0.0)", "rgba(88, 231, 159, 0)", +"hsla(180, 75%, 62.5%, 0.0)", "rgba(88, 231, 231, 0)", +"hsla(210, 75%, 62.5%, 0.0)", "rgba(88, 159, 231, 0)", +"hsla(240, 75%, 62.5%, 0.0)", "rgba(88, 88, 231, 0)", +"hsla(270, 75%, 62.5%, 0.0)", "rgba(159, 88, 231, 0)", +"hsla(300, 75%, 62.5%, 0.0)", "rgba(231, 88, 231, 0)", +"hsla(330, 75%, 62.5%, 0.0)", "rgba(231, 88, 159, 0)", +"hsla(0, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 76, 0)", +"hsla(30, 87.5%, 62.5%, 0.0)", "rgba(243, 159, 76, 0)", +"hsla(60, 87.5%, 62.5%, 0.0)", "rgba(243, 243, 76, 0)", +"hsla(90, 87.5%, 62.5%, 0.0)", "rgba(159, 243, 76, 0)", +"hsla(120, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 76, 0)", +"hsla(150, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 159, 0)", +"hsla(180, 87.5%, 62.5%, 0.0)", "rgba(76, 243, 243, 0)", +"hsla(210, 87.5%, 62.5%, 0.0)", "rgba(76, 159, 243, 0)", +"hsla(240, 87.5%, 62.5%, 0.0)", "rgba(76, 76, 243, 0)", +"hsla(270, 87.5%, 62.5%, 0.0)", "rgba(159, 76, 243, 0)", +"hsla(300, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 243, 0)", +"hsla(330, 87.5%, 62.5%, 0.0)", "rgba(243, 76, 159, 0)", +"hsla(0, 100%, 62.5%, 0.0)", "rgba(255, 64, 64, 0)", +"hsla(30, 100%, 62.5%, 0.0)", "rgba(255, 159, 64, 0)", +"hsla(60, 100%, 62.5%, 0.0)", "rgba(255, 255, 64, 0)", +"hsla(90, 100%, 62.5%, 0.0)", "rgba(159, 255, 64, 0)", +"hsla(120, 100%, 62.5%, 0.0)", "rgba(64, 255, 64, 0)", +"hsla(150, 100%, 62.5%, 0.0)", "rgba(64, 255, 159, 0)", +"hsla(180, 100%, 62.5%, 0.0)", "rgba(64, 255, 255, 0)", +"hsla(210, 100%, 62.5%, 0.0)", "rgba(64, 159, 255, 0)", +"hsla(240, 100%, 62.5%, 0.0)", "rgba(64, 64, 255, 0)", +"hsla(270, 100%, 62.5%, 0.0)", "rgba(159, 64, 255, 0)", +"hsla(300, 100%, 62.5%, 0.0)", "rgba(255, 64, 255, 0)", +"hsla(330, 100%, 62.5%, 0.0)", "rgba(255, 64, 159, 0)", +"hsla(0, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(30, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(60, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(90, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(120, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(150, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(180, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(210, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(240, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(270, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(300, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(330, 0%, 75%, 0.0)", "rgba(191, 191, 191, 0)", +"hsla(0, 12.5%, 75%, 0.0)", "rgba(199, 183, 183, 0)", +"hsla(30, 12.5%, 75%, 0.0)", "rgba(199, 191, 183, 0)", +"hsla(60, 12.5%, 75%, 0.0)", "rgba(199, 199, 183, 0)", +"hsla(90, 12.5%, 75%, 0.0)", "rgba(191, 199, 183, 0)", +"hsla(120, 12.5%, 75%, 0.0)", "rgba(183, 199, 183, 0)", +"hsla(150, 12.5%, 75%, 0.0)", "rgba(183, 199, 191, 0)", +"hsla(180, 12.5%, 75%, 0.0)", "rgba(183, 199, 199, 0)", +"hsla(210, 12.5%, 75%, 0.0)", "rgba(183, 191, 199, 0)", +"hsla(240, 12.5%, 75%, 0.0)", "rgba(183, 183, 199, 0)", +"hsla(270, 12.5%, 75%, 0.0)", "rgba(191, 183, 199, 0)", +"hsla(300, 12.5%, 75%, 0.0)", "rgba(199, 183, 199, 0)", +"hsla(330, 12.5%, 75%, 0.0)", "rgba(199, 183, 191, 0)", +"hsla(0, 25%, 75%, 0.0)", "rgba(207, 175, 175, 0)", +"hsla(30, 25%, 75%, 0.0)", "rgba(207, 191, 175, 0)", +"hsla(60, 25%, 75%, 0.0)", "rgba(207, 207, 175, 0)", +"hsla(90, 25%, 75%, 0.0)", "rgba(191, 207, 175, 0)", +"hsla(120, 25%, 75%, 0.0)", "rgba(175, 207, 175, 0)", +"hsla(150, 25%, 75%, 0.0)", "rgba(175, 207, 191, 0)", +"hsla(180, 25%, 75%, 0.0)", "rgba(175, 207, 207, 0)", +"hsla(210, 25%, 75%, 0.0)", "rgba(175, 191, 207, 0)", +"hsla(240, 25%, 75%, 0.0)", "rgba(175, 175, 207, 0)", +"hsla(270, 25%, 75%, 0.0)", "rgba(191, 175, 207, 0)", +"hsla(300, 25%, 75%, 0.0)", "rgba(207, 175, 207, 0)", +"hsla(330, 25%, 75%, 0.0)", "rgba(207, 175, 191, 0)", +"hsla(0, 37.5%, 75%, 0.0)", "rgba(215, 167, 167, 0)", +"hsla(30, 37.5%, 75%, 0.0)", "rgba(215, 191, 167, 0)", +"hsla(60, 37.5%, 75%, 0.0)", "rgba(215, 215, 167, 0)", +"hsla(90, 37.5%, 75%, 0.0)", "rgba(191, 215, 167, 0)", +"hsla(120, 37.5%, 75%, 0.0)", "rgba(167, 215, 167, 0)", +"hsla(150, 37.5%, 75%, 0.0)", "rgba(167, 215, 191, 0)", +"hsla(180, 37.5%, 75%, 0.0)", "rgba(167, 215, 215, 0)", +"hsla(210, 37.5%, 75%, 0.0)", "rgba(167, 191, 215, 0)", +"hsla(240, 37.5%, 75%, 0.0)", "rgba(167, 167, 215, 0)", +"hsla(270, 37.5%, 75%, 0.0)", "rgba(191, 167, 215, 0)", +"hsla(300, 37.5%, 75%, 0.0)", "rgba(215, 167, 215, 0)", +"hsla(330, 37.5%, 75%, 0.0)", "rgba(215, 167, 191, 0)", +"hsla(0, 50%, 75%, 0.0)", "rgba(223, 159, 159, 0)", +"hsla(30, 50%, 75%, 0.0)", "rgba(223, 191, 159, 0)", +"hsla(60, 50%, 75%, 0.0)", "rgba(223, 223, 159, 0)", +"hsla(90, 50%, 75%, 0.0)", "rgba(191, 223, 159, 0)", +"hsla(120, 50%, 75%, 0.0)", "rgba(159, 223, 159, 0)", +"hsla(150, 50%, 75%, 0.0)", "rgba(159, 223, 191, 0)", +"hsla(180, 50%, 75%, 0.0)", "rgba(159, 223, 223, 0)", +"hsla(210, 50%, 75%, 0.0)", "rgba(159, 191, 223, 0)", +"hsla(240, 50%, 75%, 0.0)", "rgba(159, 159, 223, 0)", +"hsla(270, 50%, 75%, 0.0)", "rgba(191, 159, 223, 0)", +"hsla(300, 50%, 75%, 0.0)", "rgba(223, 159, 223, 0)", +"hsla(330, 50%, 75%, 0.0)", "rgba(223, 159, 191, 0)", +"hsla(0, 62.5%, 75%, 0.0)", "rgba(231, 151, 151, 0)", +"hsla(30, 62.5%, 75%, 0.0)", "rgba(231, 191, 151, 0)", +"hsla(60, 62.5%, 75%, 0.0)", "rgba(231, 231, 151, 0)", +"hsla(90, 62.5%, 75%, 0.0)", "rgba(191, 231, 151, 0)", +"hsla(120, 62.5%, 75%, 0.0)", "rgba(151, 231, 151, 0)", +"hsla(150, 62.5%, 75%, 0.0)", "rgba(151, 231, 191, 0)", +"hsla(180, 62.5%, 75%, 0.0)", "rgba(151, 231, 231, 0)", +"hsla(210, 62.5%, 75%, 0.0)", "rgba(151, 191, 231, 0)", +"hsla(240, 62.5%, 75%, 0.0)", "rgba(151, 151, 231, 0)", +"hsla(270, 62.5%, 75%, 0.0)", "rgba(191, 151, 231, 0)", +"hsla(300, 62.5%, 75%, 0.0)", "rgba(231, 151, 231, 0)", +"hsla(330, 62.5%, 75%, 0.0)", "rgba(231, 151, 191, 0)", +"hsla(0, 75%, 75%, 0.0)", "rgba(239, 143, 143, 0)", +"hsla(30, 75%, 75%, 0.0)", "rgba(239, 191, 143, 0)", +"hsla(60, 75%, 75%, 0.0)", "rgba(239, 239, 143, 0)", +"hsla(90, 75%, 75%, 0.0)", "rgba(191, 239, 143, 0)", +"hsla(120, 75%, 75%, 0.0)", "rgba(143, 239, 143, 0)", +"hsla(150, 75%, 75%, 0.0)", "rgba(143, 239, 191, 0)", +"hsla(180, 75%, 75%, 0.0)", "rgba(143, 239, 239, 0)", +"hsla(210, 75%, 75%, 0.0)", "rgba(143, 191, 239, 0)", +"hsla(240, 75%, 75%, 0.0)", "rgba(143, 143, 239, 0)", +"hsla(270, 75%, 75%, 0.0)", "rgba(191, 143, 239, 0)", +"hsla(300, 75%, 75%, 0.0)", "rgba(239, 143, 239, 0)", +"hsla(330, 75%, 75%, 0.0)", "rgba(239, 143, 191, 0)", +"hsla(0, 87.5%, 75%, 0.0)", "rgba(247, 135, 135, 0)", +"hsla(30, 87.5%, 75%, 0.0)", "rgba(247, 191, 135, 0)", +"hsla(60, 87.5%, 75%, 0.0)", "rgba(247, 247, 135, 0)", +"hsla(90, 87.5%, 75%, 0.0)", "rgba(191, 247, 135, 0)", +"hsla(120, 87.5%, 75%, 0.0)", "rgba(135, 247, 135, 0)", +"hsla(150, 87.5%, 75%, 0.0)", "rgba(135, 247, 191, 0)", +"hsla(180, 87.5%, 75%, 0.0)", "rgba(135, 247, 247, 0)", +"hsla(210, 87.5%, 75%, 0.0)", "rgba(135, 191, 247, 0)", +"hsla(240, 87.5%, 75%, 0.0)", "rgba(135, 135, 247, 0)", +"hsla(270, 87.5%, 75%, 0.0)", "rgba(191, 135, 247, 0)", +"hsla(300, 87.5%, 75%, 0.0)", "rgba(247, 135, 247, 0)", +"hsla(330, 87.5%, 75%, 0.0)", "rgba(247, 135, 191, 0)", +"hsla(0, 100%, 75%, 0.0)", "rgba(255, 128, 128, 0)", +"hsla(30, 100%, 75%, 0.0)", "rgba(255, 191, 128, 0)", +"hsla(60, 100%, 75%, 0.0)", "rgba(255, 255, 128, 0)", +"hsla(90, 100%, 75%, 0.0)", "rgba(191, 255, 128, 0)", +"hsla(120, 100%, 75%, 0.0)", "rgba(128, 255, 128, 0)", +"hsla(150, 100%, 75%, 0.0)", "rgba(128, 255, 191, 0)", +"hsla(180, 100%, 75%, 0.0)", "rgba(128, 255, 255, 0)", +"hsla(210, 100%, 75%, 0.0)", "rgba(128, 191, 255, 0)", +"hsla(240, 100%, 75%, 0.0)", "rgba(128, 128, 255, 0)", +"hsla(270, 100%, 75%, 0.0)", "rgba(191, 128, 255, 0)", +"hsla(300, 100%, 75%, 0.0)", "rgba(255, 128, 255, 0)", +"hsla(330, 100%, 75%, 0.0)", "rgba(255, 128, 191, 0)", +"hsla(0, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(30, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(60, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(90, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(120, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(150, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(180, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(210, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(240, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(270, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(300, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(330, 0%, 87.5%, 0.0)", "rgba(223, 223, 223, 0)", +"hsla(0, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 219, 0)", +"hsla(30, 12.5%, 87.5%, 0.0)", "rgba(227, 223, 219, 0)", +"hsla(60, 12.5%, 87.5%, 0.0)", "rgba(227, 227, 219, 0)", +"hsla(90, 12.5%, 87.5%, 0.0)", "rgba(223, 227, 219, 0)", +"hsla(120, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 219, 0)", +"hsla(150, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 223, 0)", +"hsla(180, 12.5%, 87.5%, 0.0)", "rgba(219, 227, 227, 0)", +"hsla(210, 12.5%, 87.5%, 0.0)", "rgba(219, 223, 227, 0)", +"hsla(240, 12.5%, 87.5%, 0.0)", "rgba(219, 219, 227, 0)", +"hsla(270, 12.5%, 87.5%, 0.0)", "rgba(223, 219, 227, 0)", +"hsla(300, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 227, 0)", +"hsla(330, 12.5%, 87.5%, 0.0)", "rgba(227, 219, 223, 0)", +"hsla(0, 25%, 87.5%, 0.0)", "rgba(231, 215, 215, 0)", +"hsla(30, 25%, 87.5%, 0.0)", "rgba(231, 223, 215, 0)", +"hsla(60, 25%, 87.5%, 0.0)", "rgba(231, 231, 215, 0)", +"hsla(90, 25%, 87.5%, 0.0)", "rgba(223, 231, 215, 0)", +"hsla(120, 25%, 87.5%, 0.0)", "rgba(215, 231, 215, 0)", +"hsla(150, 25%, 87.5%, 0.0)", "rgba(215, 231, 223, 0)", +"hsla(180, 25%, 87.5%, 0.0)", "rgba(215, 231, 231, 0)", +"hsla(210, 25%, 87.5%, 0.0)", "rgba(215, 223, 231, 0)", +"hsla(240, 25%, 87.5%, 0.0)", "rgba(215, 215, 231, 0)", +"hsla(270, 25%, 87.5%, 0.0)", "rgba(223, 215, 231, 0)", +"hsla(300, 25%, 87.5%, 0.0)", "rgba(231, 215, 231, 0)", +"hsla(330, 25%, 87.5%, 0.0)", "rgba(231, 215, 223, 0)", +"hsla(0, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 211, 0)", +"hsla(30, 37.5%, 87.5%, 0.0)", "rgba(235, 223, 211, 0)", +"hsla(60, 37.5%, 87.5%, 0.0)", "rgba(235, 235, 211, 0)", +"hsla(90, 37.5%, 87.5%, 0.0)", "rgba(223, 235, 211, 0)", +"hsla(120, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 211, 0)", +"hsla(150, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 223, 0)", +"hsla(180, 37.5%, 87.5%, 0.0)", "rgba(211, 235, 235, 0)", +"hsla(210, 37.5%, 87.5%, 0.0)", "rgba(211, 223, 235, 0)", +"hsla(240, 37.5%, 87.5%, 0.0)", "rgba(211, 211, 235, 0)", +"hsla(270, 37.5%, 87.5%, 0.0)", "rgba(223, 211, 235, 0)", +"hsla(300, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 235, 0)", +"hsla(330, 37.5%, 87.5%, 0.0)", "rgba(235, 211, 223, 0)", +"hsla(0, 50%, 87.5%, 0.0)", "rgba(239, 207, 207, 0)", +"hsla(30, 50%, 87.5%, 0.0)", "rgba(239, 223, 207, 0)", +"hsla(60, 50%, 87.5%, 0.0)", "rgba(239, 239, 207, 0)", +"hsla(90, 50%, 87.5%, 0.0)", "rgba(223, 239, 207, 0)", +"hsla(120, 50%, 87.5%, 0.0)", "rgba(207, 239, 207, 0)", +"hsla(150, 50%, 87.5%, 0.0)", "rgba(207, 239, 223, 0)", +"hsla(180, 50%, 87.5%, 0.0)", "rgba(207, 239, 239, 0)", +"hsla(210, 50%, 87.5%, 0.0)", "rgba(207, 223, 239, 0)", +"hsla(240, 50%, 87.5%, 0.0)", "rgba(207, 207, 239, 0)", +"hsla(270, 50%, 87.5%, 0.0)", "rgba(223, 207, 239, 0)", +"hsla(300, 50%, 87.5%, 0.0)", "rgba(239, 207, 239, 0)", +"hsla(330, 50%, 87.5%, 0.0)", "rgba(239, 207, 223, 0)", +"hsla(0, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 203, 0)", +"hsla(30, 62.5%, 87.5%, 0.0)", "rgba(243, 223, 203, 0)", +"hsla(60, 62.5%, 87.5%, 0.0)", "rgba(243, 243, 203, 0)", +"hsla(90, 62.5%, 87.5%, 0.0)", "rgba(223, 243, 203, 0)", +"hsla(120, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 203, 0)", +"hsla(150, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 223, 0)", +"hsla(180, 62.5%, 87.5%, 0.0)", "rgba(203, 243, 243, 0)", +"hsla(210, 62.5%, 87.5%, 0.0)", "rgba(203, 223, 243, 0)", +"hsla(240, 62.5%, 87.5%, 0.0)", "rgba(203, 203, 243, 0)", +"hsla(270, 62.5%, 87.5%, 0.0)", "rgba(223, 203, 243, 0)", +"hsla(300, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 243, 0)", +"hsla(330, 62.5%, 87.5%, 0.0)", "rgba(243, 203, 223, 0)", +"hsla(0, 75%, 87.5%, 0.0)", "rgba(247, 199, 199, 0)", +"hsla(30, 75%, 87.5%, 0.0)", "rgba(247, 223, 199, 0)", +"hsla(60, 75%, 87.5%, 0.0)", "rgba(247, 247, 199, 0)", +"hsla(90, 75%, 87.5%, 0.0)", "rgba(223, 247, 199, 0)", +"hsla(120, 75%, 87.5%, 0.0)", "rgba(199, 247, 199, 0)", +"hsla(150, 75%, 87.5%, 0.0)", "rgba(199, 247, 223, 0)", +"hsla(180, 75%, 87.5%, 0.0)", "rgba(199, 247, 247, 0)", +"hsla(210, 75%, 87.5%, 0.0)", "rgba(199, 223, 247, 0)", +"hsla(240, 75%, 87.5%, 0.0)", "rgba(199, 199, 247, 0)", +"hsla(270, 75%, 87.5%, 0.0)", "rgba(223, 199, 247, 0)", +"hsla(300, 75%, 87.5%, 0.0)", "rgba(247, 199, 247, 0)", +"hsla(330, 75%, 87.5%, 0.0)", "rgba(247, 199, 223, 0)", +"hsla(0, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 195, 0)", +"hsla(30, 87.5%, 87.5%, 0.0)", "rgba(251, 223, 195, 0)", +"hsla(60, 87.5%, 87.5%, 0.0)", "rgba(251, 251, 195, 0)", +"hsla(90, 87.5%, 87.5%, 0.0)", "rgba(223, 251, 195, 0)", +"hsla(120, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 195, 0)", +"hsla(150, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 223, 0)", +"hsla(180, 87.5%, 87.5%, 0.0)", "rgba(195, 251, 251, 0)", +"hsla(210, 87.5%, 87.5%, 0.0)", "rgba(195, 223, 251, 0)", +"hsla(240, 87.5%, 87.5%, 0.0)", "rgba(195, 195, 251, 0)", +"hsla(270, 87.5%, 87.5%, 0.0)", "rgba(223, 195, 251, 0)", +"hsla(300, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 251, 0)", +"hsla(330, 87.5%, 87.5%, 0.0)", "rgba(251, 195, 223, 0)", +"hsla(0, 100%, 87.5%, 0.0)", "rgba(255, 191, 191, 0)", +"hsla(30, 100%, 87.5%, 0.0)", "rgba(255, 223, 191, 0)", +"hsla(60, 100%, 87.5%, 0.0)", "rgba(255, 255, 191, 0)", +"hsla(90, 100%, 87.5%, 0.0)", "rgba(223, 255, 191, 0)", +"hsla(120, 100%, 87.5%, 0.0)", "rgba(191, 255, 191, 0)", +"hsla(150, 100%, 87.5%, 0.0)", "rgba(191, 255, 223, 0)", +"hsla(180, 100%, 87.5%, 0.0)", "rgba(191, 255, 255, 0)", +"hsla(210, 100%, 87.5%, 0.0)", "rgba(191, 223, 255, 0)", +"hsla(240, 100%, 87.5%, 0.0)", "rgba(191, 191, 255, 0)", +"hsla(270, 100%, 87.5%, 0.0)", "rgba(223, 191, 255, 0)", +"hsla(300, 100%, 87.5%, 0.0)", "rgba(255, 191, 255, 0)", +"hsla(330, 100%, 87.5%, 0.0)", "rgba(255, 191, 223, 0)", +"hsla(0, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 0%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 12.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 25%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 37.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 50%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 62.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 75%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 87.5%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330, 100%, 100%, 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 0% 0%)", "rgb(0, 0, 0)", +"hsl(30 0% 0%)", "rgb(0, 0, 0)", +"hsl(60 0% 0%)", "rgb(0, 0, 0)", +"hsl(90 0% 0%)", "rgb(0, 0, 0)", +"hsl(120 0% 0%)", "rgb(0, 0, 0)", +"hsl(150 0% 0%)", "rgb(0, 0, 0)", +"hsl(180 0% 0%)", "rgb(0, 0, 0)", +"hsl(210 0% 0%)", "rgb(0, 0, 0)", +"hsl(240 0% 0%)", "rgb(0, 0, 0)", +"hsl(270 0% 0%)", "rgb(0, 0, 0)", +"hsl(300 0% 0%)", "rgb(0, 0, 0)", +"hsl(330 0% 0%)", "rgb(0, 0, 0)", +"hsl(0 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(30 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(60 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(90 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(120 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(150 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(180 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(210 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(240 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(270 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(300 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(330 12.5% 0%)", "rgb(0, 0, 0)", +"hsl(0 25% 0%)", "rgb(0, 0, 0)", +"hsl(30 25% 0%)", "rgb(0, 0, 0)", +"hsl(60 25% 0%)", "rgb(0, 0, 0)", +"hsl(90 25% 0%)", "rgb(0, 0, 0)", +"hsl(120 25% 0%)", "rgb(0, 0, 0)", +"hsl(150 25% 0%)", "rgb(0, 0, 0)", +"hsl(180 25% 0%)", "rgb(0, 0, 0)", +"hsl(210 25% 0%)", "rgb(0, 0, 0)", +"hsl(240 25% 0%)", "rgb(0, 0, 0)", +"hsl(270 25% 0%)", "rgb(0, 0, 0)", +"hsl(300 25% 0%)", "rgb(0, 0, 0)", +"hsl(330 25% 0%)", "rgb(0, 0, 0)", +"hsl(0 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(30 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(60 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(90 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(120 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(150 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(180 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(210 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(240 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(270 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(300 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(330 37.5% 0%)", "rgb(0, 0, 0)", +"hsl(0 50% 0%)", "rgb(0, 0, 0)", +"hsl(30 50% 0%)", "rgb(0, 0, 0)", +"hsl(60 50% 0%)", "rgb(0, 0, 0)", +"hsl(90 50% 0%)", "rgb(0, 0, 0)", +"hsl(120 50% 0%)", "rgb(0, 0, 0)", +"hsl(150 50% 0%)", "rgb(0, 0, 0)", +"hsl(180 50% 0%)", "rgb(0, 0, 0)", +"hsl(210 50% 0%)", "rgb(0, 0, 0)", +"hsl(240 50% 0%)", "rgb(0, 0, 0)", +"hsl(270 50% 0%)", "rgb(0, 0, 0)", +"hsl(300 50% 0%)", "rgb(0, 0, 0)", +"hsl(330 50% 0%)", "rgb(0, 0, 0)", +"hsl(0 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(30 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(60 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(90 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(120 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(150 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(180 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(210 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(240 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(270 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(300 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(330 62.5% 0%)", "rgb(0, 0, 0)", +"hsl(0 75% 0%)", "rgb(0, 0, 0)", +"hsl(30 75% 0%)", "rgb(0, 0, 0)", +"hsl(60 75% 0%)", "rgb(0, 0, 0)", +"hsl(90 75% 0%)", "rgb(0, 0, 0)", +"hsl(120 75% 0%)", "rgb(0, 0, 0)", +"hsl(150 75% 0%)", "rgb(0, 0, 0)", +"hsl(180 75% 0%)", "rgb(0, 0, 0)", +"hsl(210 75% 0%)", "rgb(0, 0, 0)", +"hsl(240 75% 0%)", "rgb(0, 0, 0)", +"hsl(270 75% 0%)", "rgb(0, 0, 0)", +"hsl(300 75% 0%)", "rgb(0, 0, 0)", +"hsl(330 75% 0%)", "rgb(0, 0, 0)", +"hsl(0 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(30 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(60 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(90 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(120 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(150 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(180 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(210 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(240 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(270 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(300 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(330 87.5% 0%)", "rgb(0, 0, 0)", +"hsl(0 100% 0%)", "rgb(0, 0, 0)", +"hsl(30 100% 0%)", "rgb(0, 0, 0)", +"hsl(60 100% 0%)", "rgb(0, 0, 0)", +"hsl(90 100% 0%)", "rgb(0, 0, 0)", +"hsl(120 100% 0%)", "rgb(0, 0, 0)", +"hsl(150 100% 0%)", "rgb(0, 0, 0)", +"hsl(180 100% 0%)", "rgb(0, 0, 0)", +"hsl(210 100% 0%)", "rgb(0, 0, 0)", +"hsl(240 100% 0%)", "rgb(0, 0, 0)", +"hsl(270 100% 0%)", "rgb(0, 0, 0)", +"hsl(300 100% 0%)", "rgb(0, 0, 0)", +"hsl(330 100% 0%)", "rgb(0, 0, 0)", +"hsl(0 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(30 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(60 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(90 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(120 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(150 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(180 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(210 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(240 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(270 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(300 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(330 0% 12.5%)", "rgb(32, 32, 32)", +"hsl(0 12.5% 12.5%)", "rgb(36, 28, 28)", +"hsl(30 12.5% 12.5%)", "rgb(36, 32, 28)", +"hsl(60 12.5% 12.5%)", "rgb(36, 36, 28)", +"hsl(90 12.5% 12.5%)", "rgb(32, 36, 28)", +"hsl(120 12.5% 12.5%)", "rgb(28, 36, 28)", +"hsl(150 12.5% 12.5%)", "rgb(28, 36, 32)", +"hsl(180 12.5% 12.5%)", "rgb(28, 36, 36)", +"hsl(210 12.5% 12.5%)", "rgb(28, 32, 36)", +"hsl(240 12.5% 12.5%)", "rgb(28, 28, 36)", +"hsl(270 12.5% 12.5%)", "rgb(32, 28, 36)", +"hsl(300 12.5% 12.5%)", "rgb(36, 28, 36)", +"hsl(330 12.5% 12.5%)", "rgb(36, 28, 32)", +"hsl(0 25% 12.5%)", "rgb(40, 24, 24)", +"hsl(30 25% 12.5%)", "rgb(40, 32, 24)", +"hsl(60 25% 12.5%)", "rgb(40, 40, 24)", +"hsl(90 25% 12.5%)", "rgb(32, 40, 24)", +"hsl(120 25% 12.5%)", "rgb(24, 40, 24)", +"hsl(150 25% 12.5%)", "rgb(24, 40, 32)", +"hsl(180 25% 12.5%)", "rgb(24, 40, 40)", +"hsl(210 25% 12.5%)", "rgb(24, 32, 40)", +"hsl(240 25% 12.5%)", "rgb(24, 24, 40)", +"hsl(270 25% 12.5%)", "rgb(32, 24, 40)", +"hsl(300 25% 12.5%)", "rgb(40, 24, 40)", +"hsl(330 25% 12.5%)", "rgb(40, 24, 32)", +"hsl(0 37.5% 12.5%)", "rgb(44, 20, 20)", +"hsl(30 37.5% 12.5%)", "rgb(44, 32, 20)", +"hsl(60 37.5% 12.5%)", "rgb(44, 44, 20)", +"hsl(90 37.5% 12.5%)", "rgb(32, 44, 20)", +"hsl(120 37.5% 12.5%)", "rgb(20, 44, 20)", +"hsl(150 37.5% 12.5%)", "rgb(20, 44, 32)", +"hsl(180 37.5% 12.5%)", "rgb(20, 44, 44)", +"hsl(210 37.5% 12.5%)", "rgb(20, 32, 44)", +"hsl(240 37.5% 12.5%)", "rgb(20, 20, 44)", +"hsl(270 37.5% 12.5%)", "rgb(32, 20, 44)", +"hsl(300 37.5% 12.5%)", "rgb(44, 20, 44)", +"hsl(330 37.5% 12.5%)", "rgb(44, 20, 32)", +"hsl(0 50% 12.5%)", "rgb(48, 16, 16)", +"hsl(30 50% 12.5%)", "rgb(48, 32, 16)", +"hsl(60 50% 12.5%)", "rgb(48, 48, 16)", +"hsl(90 50% 12.5%)", "rgb(32, 48, 16)", +"hsl(120 50% 12.5%)", "rgb(16, 48, 16)", +"hsl(150 50% 12.5%)", "rgb(16, 48, 32)", +"hsl(180 50% 12.5%)", "rgb(16, 48, 48)", +"hsl(210 50% 12.5%)", "rgb(16, 32, 48)", +"hsl(240 50% 12.5%)", "rgb(16, 16, 48)", +"hsl(270 50% 12.5%)", "rgb(32, 16, 48)", +"hsl(300 50% 12.5%)", "rgb(48, 16, 48)", +"hsl(330 50% 12.5%)", "rgb(48, 16, 32)", +"hsl(0 62.5% 12.5%)", "rgb(52, 12, 12)", +"hsl(30 62.5% 12.5%)", "rgb(52, 32, 12)", +"hsl(60 62.5% 12.5%)", "rgb(52, 52, 12)", +"hsl(90 62.5% 12.5%)", "rgb(32, 52, 12)", +"hsl(120 62.5% 12.5%)", "rgb(12, 52, 12)", +"hsl(150 62.5% 12.5%)", "rgb(12, 52, 32)", +"hsl(180 62.5% 12.5%)", "rgb(12, 52, 52)", +"hsl(210 62.5% 12.5%)", "rgb(12, 32, 52)", +"hsl(240 62.5% 12.5%)", "rgb(12, 12, 52)", +"hsl(270 62.5% 12.5%)", "rgb(32, 12, 52)", +"hsl(300 62.5% 12.5%)", "rgb(52, 12, 52)", +"hsl(330 62.5% 12.5%)", "rgb(52, 12, 32)", +"hsl(0 75% 12.5%)", "rgb(56, 8, 8)", +"hsl(30 75% 12.5%)", "rgb(56, 32, 8)", +"hsl(60 75% 12.5%)", "rgb(56, 56, 8)", +"hsl(90 75% 12.5%)", "rgb(32, 56, 8)", +"hsl(120 75% 12.5%)", "rgb(8, 56, 8)", +"hsl(150 75% 12.5%)", "rgb(8, 56, 32)", +"hsl(180 75% 12.5%)", "rgb(8, 56, 56)", +"hsl(210 75% 12.5%)", "rgb(8, 32, 56)", +"hsl(240 75% 12.5%)", "rgb(8, 8, 56)", +"hsl(270 75% 12.5%)", "rgb(32, 8, 56)", +"hsl(300 75% 12.5%)", "rgb(56, 8, 56)", +"hsl(330 75% 12.5%)", "rgb(56, 8, 32)", +"hsl(0 87.5% 12.5%)", "rgb(60, 4, 4)", +"hsl(30 87.5% 12.5%)", "rgb(60, 32, 4)", +"hsl(60 87.5% 12.5%)", "rgb(60, 60, 4)", +"hsl(90 87.5% 12.5%)", "rgb(32, 60, 4)", +"hsl(120 87.5% 12.5%)", "rgb(4, 60, 4)", +"hsl(150 87.5% 12.5%)", "rgb(4, 60, 32)", +"hsl(180 87.5% 12.5%)", "rgb(4, 60, 60)", +"hsl(210 87.5% 12.5%)", "rgb(4, 32, 60)", +"hsl(240 87.5% 12.5%)", "rgb(4, 4, 60)", +"hsl(270 87.5% 12.5%)", "rgb(32, 4, 60)", +"hsl(300 87.5% 12.5%)", "rgb(60, 4, 60)", +"hsl(330 87.5% 12.5%)", "rgb(60, 4, 32)", +"hsl(0 100% 12.5%)", "rgb(64, 0, 0)", +"hsl(30 100% 12.5%)", "rgb(64, 32, 0)", +"hsl(60 100% 12.5%)", "rgb(64, 64, 0)", +"hsl(90 100% 12.5%)", "rgb(32, 64, 0)", +"hsl(120 100% 12.5%)", "rgb(0, 64, 0)", +"hsl(150 100% 12.5%)", "rgb(0, 64, 32)", +"hsl(180 100% 12.5%)", "rgb(0, 64, 64)", +"hsl(210 100% 12.5%)", "rgb(0, 32, 64)", +"hsl(240 100% 12.5%)", "rgb(0, 0, 64)", +"hsl(270 100% 12.5%)", "rgb(32, 0, 64)", +"hsl(300 100% 12.5%)", "rgb(64, 0, 64)", +"hsl(330 100% 12.5%)", "rgb(64, 0, 32)", +"hsl(0 0% 25%)", "rgb(64, 64, 64)", +"hsl(30 0% 25%)", "rgb(64, 64, 64)", +"hsl(60 0% 25%)", "rgb(64, 64, 64)", +"hsl(90 0% 25%)", "rgb(64, 64, 64)", +"hsl(120 0% 25%)", "rgb(64, 64, 64)", +"hsl(150 0% 25%)", "rgb(64, 64, 64)", +"hsl(180 0% 25%)", "rgb(64, 64, 64)", +"hsl(210 0% 25%)", "rgb(64, 64, 64)", +"hsl(240 0% 25%)", "rgb(64, 64, 64)", +"hsl(270 0% 25%)", "rgb(64, 64, 64)", +"hsl(300 0% 25%)", "rgb(64, 64, 64)", +"hsl(330 0% 25%)", "rgb(64, 64, 64)", +"hsl(0 12.5% 25%)", "rgb(72, 56, 56)", +"hsl(30 12.5% 25%)", "rgb(72, 64, 56)", +"hsl(60 12.5% 25%)", "rgb(72, 72, 56)", +"hsl(90 12.5% 25%)", "rgb(64, 72, 56)", +"hsl(120 12.5% 25%)", "rgb(56, 72, 56)", +"hsl(150 12.5% 25%)", "rgb(56, 72, 64)", +"hsl(180 12.5% 25%)", "rgb(56, 72, 72)", +"hsl(210 12.5% 25%)", "rgb(56, 64, 72)", +"hsl(240 12.5% 25%)", "rgb(56, 56, 72)", +"hsl(270 12.5% 25%)", "rgb(64, 56, 72)", +"hsl(300 12.5% 25%)", "rgb(72, 56, 72)", +"hsl(330 12.5% 25%)", "rgb(72, 56, 64)", +"hsl(0 25% 25%)", "rgb(80, 48, 48)", +"hsl(30 25% 25%)", "rgb(80, 64, 48)", +"hsl(60 25% 25%)", "rgb(80, 80, 48)", +"hsl(90 25% 25%)", "rgb(64, 80, 48)", +"hsl(120 25% 25%)", "rgb(48, 80, 48)", +"hsl(150 25% 25%)", "rgb(48, 80, 64)", +"hsl(180 25% 25%)", "rgb(48, 80, 80)", +"hsl(210 25% 25%)", "rgb(48, 64, 80)", +"hsl(240 25% 25%)", "rgb(48, 48, 80)", +"hsl(270 25% 25%)", "rgb(64, 48, 80)", +"hsl(300 25% 25%)", "rgb(80, 48, 80)", +"hsl(330 25% 25%)", "rgb(80, 48, 64)", +"hsl(0 37.5% 25%)", "rgb(88, 40, 40)", +"hsl(30 37.5% 25%)", "rgb(88, 64, 40)", +"hsl(60 37.5% 25%)", "rgb(88, 88, 40)", +"hsl(90 37.5% 25%)", "rgb(64, 88, 40)", +"hsl(120 37.5% 25%)", "rgb(40, 88, 40)", +"hsl(150 37.5% 25%)", "rgb(40, 88, 64)", +"hsl(180 37.5% 25%)", "rgb(40, 88, 88)", +"hsl(210 37.5% 25%)", "rgb(40, 64, 88)", +"hsl(240 37.5% 25%)", "rgb(40, 40, 88)", +"hsl(270 37.5% 25%)", "rgb(64, 40, 88)", +"hsl(300 37.5% 25%)", "rgb(88, 40, 88)", +"hsl(330 37.5% 25%)", "rgb(88, 40, 64)", +"hsl(0 50% 25%)", "rgb(96, 32, 32)", +"hsl(30 50% 25%)", "rgb(96, 64, 32)", +"hsl(60 50% 25%)", "rgb(96, 96, 32)", +"hsl(90 50% 25%)", "rgb(64, 96, 32)", +"hsl(120 50% 25%)", "rgb(32, 96, 32)", +"hsl(150 50% 25%)", "rgb(32, 96, 64)", +"hsl(180 50% 25%)", "rgb(32, 96, 96)", +"hsl(210 50% 25%)", "rgb(32, 64, 96)", +"hsl(240 50% 25%)", "rgb(32, 32, 96)", +"hsl(270 50% 25%)", "rgb(64, 32, 96)", +"hsl(300 50% 25%)", "rgb(96, 32, 96)", +"hsl(330 50% 25%)", "rgb(96, 32, 64)", +"hsl(0 62.5% 25%)", "rgb(104, 24, 24)", +"hsl(30 62.5% 25%)", "rgb(104, 64, 24)", +"hsl(60 62.5% 25%)", "rgb(104, 104, 24)", +"hsl(90 62.5% 25%)", "rgb(64, 104, 24)", +"hsl(120 62.5% 25%)", "rgb(24, 104, 24)", +"hsl(150 62.5% 25%)", "rgb(24, 104, 64)", +"hsl(180 62.5% 25%)", "rgb(24, 104, 104)", +"hsl(210 62.5% 25%)", "rgb(24, 64, 104)", +"hsl(240 62.5% 25%)", "rgb(24, 24, 104)", +"hsl(270 62.5% 25%)", "rgb(64, 24, 104)", +"hsl(300 62.5% 25%)", "rgb(104, 24, 104)", +"hsl(330 62.5% 25%)", "rgb(104, 24, 64)", +"hsl(0 75% 25%)", "rgb(112, 16, 16)", +"hsl(30 75% 25%)", "rgb(112, 64, 16)", +"hsl(60 75% 25%)", "rgb(112, 112, 16)", +"hsl(90 75% 25%)", "rgb(64, 112, 16)", +"hsl(120 75% 25%)", "rgb(16, 112, 16)", +"hsl(150 75% 25%)", "rgb(16, 112, 64)", +"hsl(180 75% 25%)", "rgb(16, 112, 112)", +"hsl(210 75% 25%)", "rgb(16, 64, 112)", +"hsl(240 75% 25%)", "rgb(16, 16, 112)", +"hsl(270 75% 25%)", "rgb(64, 16, 112)", +"hsl(300 75% 25%)", "rgb(112, 16, 112)", +"hsl(330 75% 25%)", "rgb(112, 16, 64)", +"hsl(0 87.5% 25%)", "rgb(120, 8, 8)", +"hsl(30 87.5% 25%)", "rgb(120, 64, 8)", +"hsl(60 87.5% 25%)", "rgb(120, 120, 8)", +"hsl(90 87.5% 25%)", "rgb(64, 120, 8)", +"hsl(120 87.5% 25%)", "rgb(8, 120, 8)", +"hsl(150 87.5% 25%)", "rgb(8, 120, 64)", +"hsl(180 87.5% 25%)", "rgb(8, 120, 120)", +"hsl(210 87.5% 25%)", "rgb(8, 64, 120)", +"hsl(240 87.5% 25%)", "rgb(8, 8, 120)", +"hsl(270 87.5% 25%)", "rgb(64, 8, 120)", +"hsl(300 87.5% 25%)", "rgb(120, 8, 120)", +"hsl(330 87.5% 25%)", "rgb(120, 8, 64)", +"hsl(0 100% 25%)", "rgb(128, 0, 0)", +"hsl(30 100% 25%)", "rgb(128, 64, 0)", +"hsl(60 100% 25%)", "rgb(128, 128, 0)", +"hsl(90 100% 25%)", "rgb(64, 128, 0)", +"hsl(120 100% 25%)", "rgb(0, 128, 0)", +"hsl(150 100% 25%)", "rgb(0, 128, 64)", +"hsl(180 100% 25%)", "rgb(0, 128, 128)", +"hsl(210 100% 25%)", "rgb(0, 64, 128)", +"hsl(240 100% 25%)", "rgb(0, 0, 128)", +"hsl(270 100% 25%)", "rgb(64, 0, 128)", +"hsl(300 100% 25%)", "rgb(128, 0, 128)", +"hsl(330 100% 25%)", "rgb(128, 0, 64)", +"hsl(0 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(30 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(60 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(90 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(120 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(150 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(180 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(210 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(240 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(270 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(300 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(330 0% 37.5%)", "rgb(96, 96, 96)", +"hsl(0 12.5% 37.5%)", "rgb(108, 84, 84)", +"hsl(30 12.5% 37.5%)", "rgb(108, 96, 84)", +"hsl(60 12.5% 37.5%)", "rgb(108, 108, 84)", +"hsl(90 12.5% 37.5%)", "rgb(96, 108, 84)", +"hsl(120 12.5% 37.5%)", "rgb(84, 108, 84)", +"hsl(150 12.5% 37.5%)", "rgb(84, 108, 96)", +"hsl(180 12.5% 37.5%)", "rgb(84, 108, 108)", +"hsl(210 12.5% 37.5%)", "rgb(84, 96, 108)", +"hsl(240 12.5% 37.5%)", "rgb(84, 84, 108)", +"hsl(270 12.5% 37.5%)", "rgb(96, 84, 108)", +"hsl(300 12.5% 37.5%)", "rgb(108, 84, 108)", +"hsl(330 12.5% 37.5%)", "rgb(108, 84, 96)", +"hsl(0 25% 37.5%)", "rgb(120, 72, 72)", +"hsl(30 25% 37.5%)", "rgb(120, 96, 72)", +"hsl(60 25% 37.5%)", "rgb(120, 120, 72)", +"hsl(90 25% 37.5%)", "rgb(96, 120, 72)", +"hsl(120 25% 37.5%)", "rgb(72, 120, 72)", +"hsl(150 25% 37.5%)", "rgb(72, 120, 96)", +"hsl(180 25% 37.5%)", "rgb(72, 120, 120)", +"hsl(210 25% 37.5%)", "rgb(72, 96, 120)", +"hsl(240 25% 37.5%)", "rgb(72, 72, 120)", +"hsl(270 25% 37.5%)", "rgb(96, 72, 120)", +"hsl(300 25% 37.5%)", "rgb(120, 72, 120)", +"hsl(330 25% 37.5%)", "rgb(120, 72, 96)", +"hsl(0 37.5% 37.5%)", "rgb(131, 60, 60)", +"hsl(30 37.5% 37.5%)", "rgb(131, 96, 60)", +"hsl(60 37.5% 37.5%)", "rgb(131, 131, 60)", +"hsl(90 37.5% 37.5%)", "rgb(96, 131, 60)", +"hsl(120 37.5% 37.5%)", "rgb(60, 131, 60)", +"hsl(150 37.5% 37.5%)", "rgb(60, 131, 96)", +"hsl(180 37.5% 37.5%)", "rgb(60, 131, 131)", +"hsl(210 37.5% 37.5%)", "rgb(60, 96, 131)", +"hsl(240 37.5% 37.5%)", "rgb(60, 60, 131)", +"hsl(270 37.5% 37.5%)", "rgb(96, 60, 131)", +"hsl(300 37.5% 37.5%)", "rgb(131, 60, 131)", +"hsl(330 37.5% 37.5%)", "rgb(131, 60, 96)", +"hsl(0 50% 37.5%)", "rgb(143, 48, 48)", +"hsl(30 50% 37.5%)", "rgb(143, 96, 48)", +"hsl(60 50% 37.5%)", "rgb(143, 143, 48)", +"hsl(90 50% 37.5%)", "rgb(96, 143, 48)", +"hsl(120 50% 37.5%)", "rgb(48, 143, 48)", +"hsl(150 50% 37.5%)", "rgb(48, 143, 96)", +"hsl(180 50% 37.5%)", "rgb(48, 143, 143)", +"hsl(210 50% 37.5%)", "rgb(48, 96, 143)", +"hsl(240 50% 37.5%)", "rgb(48, 48, 143)", +"hsl(270 50% 37.5%)", "rgb(96, 48, 143)", +"hsl(300 50% 37.5%)", "rgb(143, 48, 143)", +"hsl(330 50% 37.5%)", "rgb(143, 48, 96)", +"hsl(0 62.5% 37.5%)", "rgb(155, 36, 36)", +"hsl(30 62.5% 37.5%)", "rgb(155, 96, 36)", +"hsl(60 62.5% 37.5%)", "rgb(155, 155, 36)", +"hsl(90 62.5% 37.5%)", "rgb(96, 155, 36)", +"hsl(120 62.5% 37.5%)", "rgb(36, 155, 36)", +"hsl(150 62.5% 37.5%)", "rgb(36, 155, 96)", +"hsl(180 62.5% 37.5%)", "rgb(36, 155, 155)", +"hsl(210 62.5% 37.5%)", "rgb(36, 96, 155)", +"hsl(240 62.5% 37.5%)", "rgb(36, 36, 155)", +"hsl(270 62.5% 37.5%)", "rgb(96, 36, 155)", +"hsl(300 62.5% 37.5%)", "rgb(155, 36, 155)", +"hsl(330 62.5% 37.5%)", "rgb(155, 36, 96)", +"hsl(0 75% 37.5%)", "rgb(167, 24, 24)", +"hsl(30 75% 37.5%)", "rgb(167, 96, 24)", +"hsl(60 75% 37.5%)", "rgb(167, 167, 24)", +"hsl(90 75% 37.5%)", "rgb(96, 167, 24)", +"hsl(120 75% 37.5%)", "rgb(24, 167, 24)", +"hsl(150 75% 37.5%)", "rgb(24, 167, 96)", +"hsl(180 75% 37.5%)", "rgb(24, 167, 167)", +"hsl(210 75% 37.5%)", "rgb(24, 96, 167)", +"hsl(240 75% 37.5%)", "rgb(24, 24, 167)", +"hsl(270 75% 37.5%)", "rgb(96, 24, 167)", +"hsl(300 75% 37.5%)", "rgb(167, 24, 167)", +"hsl(330 75% 37.5%)", "rgb(167, 24, 96)", +"hsl(0 87.5% 37.5%)", "rgb(179, 12, 12)", +"hsl(30 87.5% 37.5%)", "rgb(179, 96, 12)", +"hsl(60 87.5% 37.5%)", "rgb(179, 179, 12)", +"hsl(90 87.5% 37.5%)", "rgb(96, 179, 12)", +"hsl(120 87.5% 37.5%)", "rgb(12, 179, 12)", +"hsl(150 87.5% 37.5%)", "rgb(12, 179, 96)", +"hsl(180 87.5% 37.5%)", "rgb(12, 179, 179)", +"hsl(210 87.5% 37.5%)", "rgb(12, 96, 179)", +"hsl(240 87.5% 37.5%)", "rgb(12, 12, 179)", +"hsl(270 87.5% 37.5%)", "rgb(96, 12, 179)", +"hsl(300 87.5% 37.5%)", "rgb(179, 12, 179)", +"hsl(330 87.5% 37.5%)", "rgb(179, 12, 96)", +"hsl(0 100% 37.5%)", "rgb(191, 0, 0)", +"hsl(30 100% 37.5%)", "rgb(191, 96, 0)", +"hsl(60 100% 37.5%)", "rgb(191, 191, 0)", +"hsl(90 100% 37.5%)", "rgb(96, 191, 0)", +"hsl(120 100% 37.5%)", "rgb(0, 191, 0)", +"hsl(150 100% 37.5%)", "rgb(0, 191, 96)", +"hsl(180 100% 37.5%)", "rgb(0, 191, 191)", +"hsl(210 100% 37.5%)", "rgb(0, 96, 191)", +"hsl(240 100% 37.5%)", "rgb(0, 0, 191)", +"hsl(270 100% 37.5%)", "rgb(96, 0, 191)", +"hsl(300 100% 37.5%)", "rgb(191, 0, 191)", +"hsl(330 100% 37.5%)", "rgb(191, 0, 96)", +"hsl(0 0% 50%)", "rgb(128, 128, 128)", +"hsl(30 0% 50%)", "rgb(128, 128, 128)", +"hsl(60 0% 50%)", "rgb(128, 128, 128)", +"hsl(90 0% 50%)", "rgb(128, 128, 128)", +"hsl(120 0% 50%)", "rgb(128, 128, 128)", +"hsl(150 0% 50%)", "rgb(128, 128, 128)", +"hsl(180 0% 50%)", "rgb(128, 128, 128)", +"hsl(210 0% 50%)", "rgb(128, 128, 128)", +"hsl(240 0% 50%)", "rgb(128, 128, 128)", +"hsl(270 0% 50%)", "rgb(128, 128, 128)", +"hsl(300 0% 50%)", "rgb(128, 128, 128)", +"hsl(330 0% 50%)", "rgb(128, 128, 128)", +"hsl(0 12.5% 50%)", "rgb(143, 112, 112)", +"hsl(30 12.5% 50%)", "rgb(143, 128, 112)", +"hsl(60 12.5% 50%)", "rgb(143, 143, 112)", +"hsl(90 12.5% 50%)", "rgb(128, 143, 112)", +"hsl(120 12.5% 50%)", "rgb(112, 143, 112)", +"hsl(150 12.5% 50%)", "rgb(112, 143, 128)", +"hsl(180 12.5% 50%)", "rgb(112, 143, 143)", +"hsl(210 12.5% 50%)", "rgb(112, 128, 143)", +"hsl(240 12.5% 50%)", "rgb(112, 112, 143)", +"hsl(270 12.5% 50%)", "rgb(128, 112, 143)", +"hsl(300 12.5% 50%)", "rgb(143, 112, 143)", +"hsl(330 12.5% 50%)", "rgb(143, 112, 128)", +"hsl(0 25% 50%)", "rgb(159, 96, 96)", +"hsl(30 25% 50%)", "rgb(159, 128, 96)", +"hsl(60 25% 50%)", "rgb(159, 159, 96)", +"hsl(90 25% 50%)", "rgb(128, 159, 96)", +"hsl(120 25% 50%)", "rgb(96, 159, 96)", +"hsl(150 25% 50%)", "rgb(96, 159, 128)", +"hsl(180 25% 50%)", "rgb(96, 159, 159)", +"hsl(210 25% 50%)", "rgb(96, 128, 159)", +"hsl(240 25% 50%)", "rgb(96, 96, 159)", +"hsl(270 25% 50%)", "rgb(128, 96, 159)", +"hsl(300 25% 50%)", "rgb(159, 96, 159)", +"hsl(330 25% 50%)", "rgb(159, 96, 128)", +"hsl(0 37.5% 50%)", "rgb(175, 80, 80)", +"hsl(30 37.5% 50%)", "rgb(175, 128, 80)", +"hsl(60 37.5% 50%)", "rgb(175, 175, 80)", +"hsl(90 37.5% 50%)", "rgb(128, 175, 80)", +"hsl(120 37.5% 50%)", "rgb(80, 175, 80)", +"hsl(150 37.5% 50%)", "rgb(80, 175, 128)", +"hsl(180 37.5% 50%)", "rgb(80, 175, 175)", +"hsl(210 37.5% 50%)", "rgb(80, 128, 175)", +"hsl(240 37.5% 50%)", "rgb(80, 80, 175)", +"hsl(270 37.5% 50%)", "rgb(128, 80, 175)", +"hsl(300 37.5% 50%)", "rgb(175, 80, 175)", +"hsl(330 37.5% 50%)", "rgb(175, 80, 128)", +"hsl(0 50% 50%)", "rgb(191, 64, 64)", +"hsl(30 50% 50%)", "rgb(191, 128, 64)", +"hsl(60 50% 50%)", "rgb(191, 191, 64)", +"hsl(90 50% 50%)", "rgb(128, 191, 64)", +"hsl(120 50% 50%)", "rgb(64, 191, 64)", +"hsl(150 50% 50%)", "rgb(64, 191, 128)", +"hsl(180 50% 50%)", "rgb(64, 191, 191)", +"hsl(210 50% 50%)", "rgb(64, 128, 191)", +"hsl(240 50% 50%)", "rgb(64, 64, 191)", +"hsl(270 50% 50%)", "rgb(128, 64, 191)", +"hsl(300 50% 50%)", "rgb(191, 64, 191)", +"hsl(330 50% 50%)", "rgb(191, 64, 128)", +"hsl(0 62.5% 50%)", "rgb(207, 48, 48)", +"hsl(30 62.5% 50%)", "rgb(207, 128, 48)", +"hsl(60 62.5% 50%)", "rgb(207, 207, 48)", +"hsl(90 62.5% 50%)", "rgb(128, 207, 48)", +"hsl(120 62.5% 50%)", "rgb(48, 207, 48)", +"hsl(150 62.5% 50%)", "rgb(48, 207, 128)", +"hsl(180 62.5% 50%)", "rgb(48, 207, 207)", +"hsl(210 62.5% 50%)", "rgb(48, 128, 207)", +"hsl(240 62.5% 50%)", "rgb(48, 48, 207)", +"hsl(270 62.5% 50%)", "rgb(128, 48, 207)", +"hsl(300 62.5% 50%)", "rgb(207, 48, 207)", +"hsl(330 62.5% 50%)", "rgb(207, 48, 128)", +"hsl(0 75% 50%)", "rgb(223, 32, 32)", +"hsl(30 75% 50%)", "rgb(223, 128, 32)", +"hsl(60 75% 50%)", "rgb(223, 223, 32)", +"hsl(90 75% 50%)", "rgb(128, 223, 32)", +"hsl(120 75% 50%)", "rgb(32, 223, 32)", +"hsl(150 75% 50%)", "rgb(32, 223, 128)", +"hsl(180 75% 50%)", "rgb(32, 223, 223)", +"hsl(210 75% 50%)", "rgb(32, 128, 223)", +"hsl(240 75% 50%)", "rgb(32, 32, 223)", +"hsl(270 75% 50%)", "rgb(128, 32, 223)", +"hsl(300 75% 50%)", "rgb(223, 32, 223)", +"hsl(330 75% 50%)", "rgb(223, 32, 128)", +"hsl(0 87.5% 50%)", "rgb(239, 16, 16)", +"hsl(30 87.5% 50%)", "rgb(239, 128, 16)", +"hsl(60 87.5% 50%)", "rgb(239, 239, 16)", +"hsl(90 87.5% 50%)", "rgb(128, 239, 16)", +"hsl(120 87.5% 50%)", "rgb(16, 239, 16)", +"hsl(150 87.5% 50%)", "rgb(16, 239, 128)", +"hsl(180 87.5% 50%)", "rgb(16, 239, 239)", +"hsl(210 87.5% 50%)", "rgb(16, 128, 239)", +"hsl(240 87.5% 50%)", "rgb(16, 16, 239)", +"hsl(270 87.5% 50%)", "rgb(128, 16, 239)", +"hsl(300 87.5% 50%)", "rgb(239, 16, 239)", +"hsl(330 87.5% 50%)", "rgb(239, 16, 128)", +"hsl(0 100% 50%)", "rgb(255, 0, 0)", +"hsl(30 100% 50%)", "rgb(255, 128, 0)", +"hsl(60 100% 50%)", "rgb(255, 255, 0)", +"hsl(90 100% 50%)", "rgb(128, 255, 0)", +"hsl(120 100% 50%)", "rgb(0, 255, 0)", +"hsl(150 100% 50%)", "rgb(0, 255, 128)", +"hsl(180 100% 50%)", "rgb(0, 255, 255)", +"hsl(210 100% 50%)", "rgb(0, 128, 255)", +"hsl(240 100% 50%)", "rgb(0, 0, 255)", +"hsl(270 100% 50%)", "rgb(128, 0, 255)", +"hsl(300 100% 50%)", "rgb(255, 0, 255)", +"hsl(330 100% 50%)", "rgb(255, 0, 128)", +"hsl(0 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(30 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(60 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(90 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(120 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(150 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(180 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(210 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(240 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(270 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(300 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(330 0% 62.5%)", "rgb(159, 159, 159)", +"hsl(0 12.5% 62.5%)", "rgb(171, 147, 147)", +"hsl(30 12.5% 62.5%)", "rgb(171, 159, 147)", +"hsl(60 12.5% 62.5%)", "rgb(171, 171, 147)", +"hsl(90 12.5% 62.5%)", "rgb(159, 171, 147)", +"hsl(120 12.5% 62.5%)", "rgb(147, 171, 147)", +"hsl(150 12.5% 62.5%)", "rgb(147, 171, 159)", +"hsl(180 12.5% 62.5%)", "rgb(147, 171, 171)", +"hsl(210 12.5% 62.5%)", "rgb(147, 159, 171)", +"hsl(240 12.5% 62.5%)", "rgb(147, 147, 171)", +"hsl(270 12.5% 62.5%)", "rgb(159, 147, 171)", +"hsl(300 12.5% 62.5%)", "rgb(171, 147, 171)", +"hsl(330 12.5% 62.5%)", "rgb(171, 147, 159)", +"hsl(0 25% 62.5%)", "rgb(183, 135, 135)", +"hsl(30 25% 62.5%)", "rgb(183, 159, 135)", +"hsl(60 25% 62.5%)", "rgb(183, 183, 135)", +"hsl(90 25% 62.5%)", "rgb(159, 183, 135)", +"hsl(120 25% 62.5%)", "rgb(135, 183, 135)", +"hsl(150 25% 62.5%)", "rgb(135, 183, 159)", +"hsl(180 25% 62.5%)", "rgb(135, 183, 183)", +"hsl(210 25% 62.5%)", "rgb(135, 159, 183)", +"hsl(240 25% 62.5%)", "rgb(135, 135, 183)", +"hsl(270 25% 62.5%)", "rgb(159, 135, 183)", +"hsl(300 25% 62.5%)", "rgb(183, 135, 183)", +"hsl(330 25% 62.5%)", "rgb(183, 135, 159)", +"hsl(0 37.5% 62.5%)", "rgb(195, 124, 124)", +"hsl(30 37.5% 62.5%)", "rgb(195, 159, 124)", +"hsl(60 37.5% 62.5%)", "rgb(195, 195, 124)", +"hsl(90 37.5% 62.5%)", "rgb(159, 195, 124)", +"hsl(120 37.5% 62.5%)", "rgb(124, 195, 124)", +"hsl(150 37.5% 62.5%)", "rgb(124, 195, 159)", +"hsl(180 37.5% 62.5%)", "rgb(124, 195, 195)", +"hsl(210 37.5% 62.5%)", "rgb(124, 159, 195)", +"hsl(240 37.5% 62.5%)", "rgb(124, 124, 195)", +"hsl(270 37.5% 62.5%)", "rgb(159, 124, 195)", +"hsl(300 37.5% 62.5%)", "rgb(195, 124, 195)", +"hsl(330 37.5% 62.5%)", "rgb(195, 124, 159)", +"hsl(0 50% 62.5%)", "rgb(207, 112, 112)", +"hsl(30 50% 62.5%)", "rgb(207, 159, 112)", +"hsl(60 50% 62.5%)", "rgb(207, 207, 112)", +"hsl(90 50% 62.5%)", "rgb(159, 207, 112)", +"hsl(120 50% 62.5%)", "rgb(112, 207, 112)", +"hsl(150 50% 62.5%)", "rgb(112, 207, 159)", +"hsl(180 50% 62.5%)", "rgb(112, 207, 207)", +"hsl(210 50% 62.5%)", "rgb(112, 159, 207)", +"hsl(240 50% 62.5%)", "rgb(112, 112, 207)", +"hsl(270 50% 62.5%)", "rgb(159, 112, 207)", +"hsl(300 50% 62.5%)", "rgb(207, 112, 207)", +"hsl(330 50% 62.5%)", "rgb(207, 112, 159)", +"hsl(0 62.5% 62.5%)", "rgb(219, 100, 100)", +"hsl(30 62.5% 62.5%)", "rgb(219, 159, 100)", +"hsl(60 62.5% 62.5%)", "rgb(219, 219, 100)", +"hsl(90 62.5% 62.5%)", "rgb(159, 219, 100)", +"hsl(120 62.5% 62.5%)", "rgb(100, 219, 100)", +"hsl(150 62.5% 62.5%)", "rgb(100, 219, 159)", +"hsl(180 62.5% 62.5%)", "rgb(100, 219, 219)", +"hsl(210 62.5% 62.5%)", "rgb(100, 159, 219)", +"hsl(240 62.5% 62.5%)", "rgb(100, 100, 219)", +"hsl(270 62.5% 62.5%)", "rgb(159, 100, 219)", +"hsl(300 62.5% 62.5%)", "rgb(219, 100, 219)", +"hsl(330 62.5% 62.5%)", "rgb(219, 100, 159)", +"hsl(0 75% 62.5%)", "rgb(231, 88, 88)", +"hsl(30 75% 62.5%)", "rgb(231, 159, 88)", +"hsl(60 75% 62.5%)", "rgb(231, 231, 88)", +"hsl(90 75% 62.5%)", "rgb(159, 231, 88)", +"hsl(120 75% 62.5%)", "rgb(88, 231, 88)", +"hsl(150 75% 62.5%)", "rgb(88, 231, 159)", +"hsl(180 75% 62.5%)", "rgb(88, 231, 231)", +"hsl(210 75% 62.5%)", "rgb(88, 159, 231)", +"hsl(240 75% 62.5%)", "rgb(88, 88, 231)", +"hsl(270 75% 62.5%)", "rgb(159, 88, 231)", +"hsl(300 75% 62.5%)", "rgb(231, 88, 231)", +"hsl(330 75% 62.5%)", "rgb(231, 88, 159)", +"hsl(0 87.5% 62.5%)", "rgb(243, 76, 76)", +"hsl(30 87.5% 62.5%)", "rgb(243, 159, 76)", +"hsl(60 87.5% 62.5%)", "rgb(243, 243, 76)", +"hsl(90 87.5% 62.5%)", "rgb(159, 243, 76)", +"hsl(120 87.5% 62.5%)", "rgb(76, 243, 76)", +"hsl(150 87.5% 62.5%)", "rgb(76, 243, 159)", +"hsl(180 87.5% 62.5%)", "rgb(76, 243, 243)", +"hsl(210 87.5% 62.5%)", "rgb(76, 159, 243)", +"hsl(240 87.5% 62.5%)", "rgb(76, 76, 243)", +"hsl(270 87.5% 62.5%)", "rgb(159, 76, 243)", +"hsl(300 87.5% 62.5%)", "rgb(243, 76, 243)", +"hsl(330 87.5% 62.5%)", "rgb(243, 76, 159)", +"hsl(0 100% 62.5%)", "rgb(255, 64, 64)", +"hsl(30 100% 62.5%)", "rgb(255, 159, 64)", +"hsl(60 100% 62.5%)", "rgb(255, 255, 64)", +"hsl(90 100% 62.5%)", "rgb(159, 255, 64)", +"hsl(120 100% 62.5%)", "rgb(64, 255, 64)", +"hsl(150 100% 62.5%)", "rgb(64, 255, 159)", +"hsl(180 100% 62.5%)", "rgb(64, 255, 255)", +"hsl(210 100% 62.5%)", "rgb(64, 159, 255)", +"hsl(240 100% 62.5%)", "rgb(64, 64, 255)", +"hsl(270 100% 62.5%)", "rgb(159, 64, 255)", +"hsl(300 100% 62.5%)", "rgb(255, 64, 255)", +"hsl(330 100% 62.5%)", "rgb(255, 64, 159)", +"hsl(0 0% 75%)", "rgb(191, 191, 191)", +"hsl(30 0% 75%)", "rgb(191, 191, 191)", +"hsl(60 0% 75%)", "rgb(191, 191, 191)", +"hsl(90 0% 75%)", "rgb(191, 191, 191)", +"hsl(120 0% 75%)", "rgb(191, 191, 191)", +"hsl(150 0% 75%)", "rgb(191, 191, 191)", +"hsl(180 0% 75%)", "rgb(191, 191, 191)", +"hsl(210 0% 75%)", "rgb(191, 191, 191)", +"hsl(240 0% 75%)", "rgb(191, 191, 191)", +"hsl(270 0% 75%)", "rgb(191, 191, 191)", +"hsl(300 0% 75%)", "rgb(191, 191, 191)", +"hsl(330 0% 75%)", "rgb(191, 191, 191)", +"hsl(0 12.5% 75%)", "rgb(199, 183, 183)", +"hsl(30 12.5% 75%)", "rgb(199, 191, 183)", +"hsl(60 12.5% 75%)", "rgb(199, 199, 183)", +"hsl(90 12.5% 75%)", "rgb(191, 199, 183)", +"hsl(120 12.5% 75%)", "rgb(183, 199, 183)", +"hsl(150 12.5% 75%)", "rgb(183, 199, 191)", +"hsl(180 12.5% 75%)", "rgb(183, 199, 199)", +"hsl(210 12.5% 75%)", "rgb(183, 191, 199)", +"hsl(240 12.5% 75%)", "rgb(183, 183, 199)", +"hsl(270 12.5% 75%)", "rgb(191, 183, 199)", +"hsl(300 12.5% 75%)", "rgb(199, 183, 199)", +"hsl(330 12.5% 75%)", "rgb(199, 183, 191)", +"hsl(0 25% 75%)", "rgb(207, 175, 175)", +"hsl(30 25% 75%)", "rgb(207, 191, 175)", +"hsl(60 25% 75%)", "rgb(207, 207, 175)", +"hsl(90 25% 75%)", "rgb(191, 207, 175)", +"hsl(120 25% 75%)", "rgb(175, 207, 175)", +"hsl(150 25% 75%)", "rgb(175, 207, 191)", +"hsl(180 25% 75%)", "rgb(175, 207, 207)", +"hsl(210 25% 75%)", "rgb(175, 191, 207)", +"hsl(240 25% 75%)", "rgb(175, 175, 207)", +"hsl(270 25% 75%)", "rgb(191, 175, 207)", +"hsl(300 25% 75%)", "rgb(207, 175, 207)", +"hsl(330 25% 75%)", "rgb(207, 175, 191)", +"hsl(0 37.5% 75%)", "rgb(215, 167, 167)", +"hsl(30 37.5% 75%)", "rgb(215, 191, 167)", +"hsl(60 37.5% 75%)", "rgb(215, 215, 167)", +"hsl(90 37.5% 75%)", "rgb(191, 215, 167)", +"hsl(120 37.5% 75%)", "rgb(167, 215, 167)", +"hsl(150 37.5% 75%)", "rgb(167, 215, 191)", +"hsl(180 37.5% 75%)", "rgb(167, 215, 215)", +"hsl(210 37.5% 75%)", "rgb(167, 191, 215)", +"hsl(240 37.5% 75%)", "rgb(167, 167, 215)", +"hsl(270 37.5% 75%)", "rgb(191, 167, 215)", +"hsl(300 37.5% 75%)", "rgb(215, 167, 215)", +"hsl(330 37.5% 75%)", "rgb(215, 167, 191)", +"hsl(0 50% 75%)", "rgb(223, 159, 159)", +"hsl(30 50% 75%)", "rgb(223, 191, 159)", +"hsl(60 50% 75%)", "rgb(223, 223, 159)", +"hsl(90 50% 75%)", "rgb(191, 223, 159)", +"hsl(120 50% 75%)", "rgb(159, 223, 159)", +"hsl(150 50% 75%)", "rgb(159, 223, 191)", +"hsl(180 50% 75%)", "rgb(159, 223, 223)", +"hsl(210 50% 75%)", "rgb(159, 191, 223)", +"hsl(240 50% 75%)", "rgb(159, 159, 223)", +"hsl(270 50% 75%)", "rgb(191, 159, 223)", +"hsl(300 50% 75%)", "rgb(223, 159, 223)", +"hsl(330 50% 75%)", "rgb(223, 159, 191)", +"hsl(0 62.5% 75%)", "rgb(231, 151, 151)", +"hsl(30 62.5% 75%)", "rgb(231, 191, 151)", +"hsl(60 62.5% 75%)", "rgb(231, 231, 151)", +"hsl(90 62.5% 75%)", "rgb(191, 231, 151)", +"hsl(120 62.5% 75%)", "rgb(151, 231, 151)", +"hsl(150 62.5% 75%)", "rgb(151, 231, 191)", +"hsl(180 62.5% 75%)", "rgb(151, 231, 231)", +"hsl(210 62.5% 75%)", "rgb(151, 191, 231)", +"hsl(240 62.5% 75%)", "rgb(151, 151, 231)", +"hsl(270 62.5% 75%)", "rgb(191, 151, 231)", +"hsl(300 62.5% 75%)", "rgb(231, 151, 231)", +"hsl(330 62.5% 75%)", "rgb(231, 151, 191)", +"hsl(0 75% 75%)", "rgb(239, 143, 143)", +"hsl(30 75% 75%)", "rgb(239, 191, 143)", +"hsl(60 75% 75%)", "rgb(239, 239, 143)", +"hsl(90 75% 75%)", "rgb(191, 239, 143)", +"hsl(120 75% 75%)", "rgb(143, 239, 143)", +"hsl(150 75% 75%)", "rgb(143, 239, 191)", +"hsl(180 75% 75%)", "rgb(143, 239, 239)", +"hsl(210 75% 75%)", "rgb(143, 191, 239)", +"hsl(240 75% 75%)", "rgb(143, 143, 239)", +"hsl(270 75% 75%)", "rgb(191, 143, 239)", +"hsl(300 75% 75%)", "rgb(239, 143, 239)", +"hsl(330 75% 75%)", "rgb(239, 143, 191)", +"hsl(0 87.5% 75%)", "rgb(247, 135, 135)", +"hsl(30 87.5% 75%)", "rgb(247, 191, 135)", +"hsl(60 87.5% 75%)", "rgb(247, 247, 135)", +"hsl(90 87.5% 75%)", "rgb(191, 247, 135)", +"hsl(120 87.5% 75%)", "rgb(135, 247, 135)", +"hsl(150 87.5% 75%)", "rgb(135, 247, 191)", +"hsl(180 87.5% 75%)", "rgb(135, 247, 247)", +"hsl(210 87.5% 75%)", "rgb(135, 191, 247)", +"hsl(240 87.5% 75%)", "rgb(135, 135, 247)", +"hsl(270 87.5% 75%)", "rgb(191, 135, 247)", +"hsl(300 87.5% 75%)", "rgb(247, 135, 247)", +"hsl(330 87.5% 75%)", "rgb(247, 135, 191)", +"hsl(0 100% 75%)", "rgb(255, 128, 128)", +"hsl(30 100% 75%)", "rgb(255, 191, 128)", +"hsl(60 100% 75%)", "rgb(255, 255, 128)", +"hsl(90 100% 75%)", "rgb(191, 255, 128)", +"hsl(120 100% 75%)", "rgb(128, 255, 128)", +"hsl(150 100% 75%)", "rgb(128, 255, 191)", +"hsl(180 100% 75%)", "rgb(128, 255, 255)", +"hsl(210 100% 75%)", "rgb(128, 191, 255)", +"hsl(240 100% 75%)", "rgb(128, 128, 255)", +"hsl(270 100% 75%)", "rgb(191, 128, 255)", +"hsl(300 100% 75%)", "rgb(255, 128, 255)", +"hsl(330 100% 75%)", "rgb(255, 128, 191)", +"hsl(0 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(30 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(60 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(90 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(120 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(150 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(180 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(210 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(240 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(270 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(300 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(330 0% 87.5%)", "rgb(223, 223, 223)", +"hsl(0 12.5% 87.5%)", "rgb(227, 219, 219)", +"hsl(30 12.5% 87.5%)", "rgb(227, 223, 219)", +"hsl(60 12.5% 87.5%)", "rgb(227, 227, 219)", +"hsl(90 12.5% 87.5%)", "rgb(223, 227, 219)", +"hsl(120 12.5% 87.5%)", "rgb(219, 227, 219)", +"hsl(150 12.5% 87.5%)", "rgb(219, 227, 223)", +"hsl(180 12.5% 87.5%)", "rgb(219, 227, 227)", +"hsl(210 12.5% 87.5%)", "rgb(219, 223, 227)", +"hsl(240 12.5% 87.5%)", "rgb(219, 219, 227)", +"hsl(270 12.5% 87.5%)", "rgb(223, 219, 227)", +"hsl(300 12.5% 87.5%)", "rgb(227, 219, 227)", +"hsl(330 12.5% 87.5%)", "rgb(227, 219, 223)", +"hsl(0 25% 87.5%)", "rgb(231, 215, 215)", +"hsl(30 25% 87.5%)", "rgb(231, 223, 215)", +"hsl(60 25% 87.5%)", "rgb(231, 231, 215)", +"hsl(90 25% 87.5%)", "rgb(223, 231, 215)", +"hsl(120 25% 87.5%)", "rgb(215, 231, 215)", +"hsl(150 25% 87.5%)", "rgb(215, 231, 223)", +"hsl(180 25% 87.5%)", "rgb(215, 231, 231)", +"hsl(210 25% 87.5%)", "rgb(215, 223, 231)", +"hsl(240 25% 87.5%)", "rgb(215, 215, 231)", +"hsl(270 25% 87.5%)", "rgb(223, 215, 231)", +"hsl(300 25% 87.5%)", "rgb(231, 215, 231)", +"hsl(330 25% 87.5%)", "rgb(231, 215, 223)", +"hsl(0 37.5% 87.5%)", "rgb(235, 211, 211)", +"hsl(30 37.5% 87.5%)", "rgb(235, 223, 211)", +"hsl(60 37.5% 87.5%)", "rgb(235, 235, 211)", +"hsl(90 37.5% 87.5%)", "rgb(223, 235, 211)", +"hsl(120 37.5% 87.5%)", "rgb(211, 235, 211)", +"hsl(150 37.5% 87.5%)", "rgb(211, 235, 223)", +"hsl(180 37.5% 87.5%)", "rgb(211, 235, 235)", +"hsl(210 37.5% 87.5%)", "rgb(211, 223, 235)", +"hsl(240 37.5% 87.5%)", "rgb(211, 211, 235)", +"hsl(270 37.5% 87.5%)", "rgb(223, 211, 235)", +"hsl(300 37.5% 87.5%)", "rgb(235, 211, 235)", +"hsl(330 37.5% 87.5%)", "rgb(235, 211, 223)", +"hsl(0 50% 87.5%)", "rgb(239, 207, 207)", +"hsl(30 50% 87.5%)", "rgb(239, 223, 207)", +"hsl(60 50% 87.5%)", "rgb(239, 239, 207)", +"hsl(90 50% 87.5%)", "rgb(223, 239, 207)", +"hsl(120 50% 87.5%)", "rgb(207, 239, 207)", +"hsl(150 50% 87.5%)", "rgb(207, 239, 223)", +"hsl(180 50% 87.5%)", "rgb(207, 239, 239)", +"hsl(210 50% 87.5%)", "rgb(207, 223, 239)", +"hsl(240 50% 87.5%)", "rgb(207, 207, 239)", +"hsl(270 50% 87.5%)", "rgb(223, 207, 239)", +"hsl(300 50% 87.5%)", "rgb(239, 207, 239)", +"hsl(330 50% 87.5%)", "rgb(239, 207, 223)", +"hsl(0 62.5% 87.5%)", "rgb(243, 203, 203)", +"hsl(30 62.5% 87.5%)", "rgb(243, 223, 203)", +"hsl(60 62.5% 87.5%)", "rgb(243, 243, 203)", +"hsl(90 62.5% 87.5%)", "rgb(223, 243, 203)", +"hsl(120 62.5% 87.5%)", "rgb(203, 243, 203)", +"hsl(150 62.5% 87.5%)", "rgb(203, 243, 223)", +"hsl(180 62.5% 87.5%)", "rgb(203, 243, 243)", +"hsl(210 62.5% 87.5%)", "rgb(203, 223, 243)", +"hsl(240 62.5% 87.5%)", "rgb(203, 203, 243)", +"hsl(270 62.5% 87.5%)", "rgb(223, 203, 243)", +"hsl(300 62.5% 87.5%)", "rgb(243, 203, 243)", +"hsl(330 62.5% 87.5%)", "rgb(243, 203, 223)", +"hsl(0 75% 87.5%)", "rgb(247, 199, 199)", +"hsl(30 75% 87.5%)", "rgb(247, 223, 199)", +"hsl(60 75% 87.5%)", "rgb(247, 247, 199)", +"hsl(90 75% 87.5%)", "rgb(223, 247, 199)", +"hsl(120 75% 87.5%)", "rgb(199, 247, 199)", +"hsl(150 75% 87.5%)", "rgb(199, 247, 223)", +"hsl(180 75% 87.5%)", "rgb(199, 247, 247)", +"hsl(210 75% 87.5%)", "rgb(199, 223, 247)", +"hsl(240 75% 87.5%)", "rgb(199, 199, 247)", +"hsl(270 75% 87.5%)", "rgb(223, 199, 247)", +"hsl(300 75% 87.5%)", "rgb(247, 199, 247)", +"hsl(330 75% 87.5%)", "rgb(247, 199, 223)", +"hsl(0 87.5% 87.5%)", "rgb(251, 195, 195)", +"hsl(30 87.5% 87.5%)", "rgb(251, 223, 195)", +"hsl(60 87.5% 87.5%)", "rgb(251, 251, 195)", +"hsl(90 87.5% 87.5%)", "rgb(223, 251, 195)", +"hsl(120 87.5% 87.5%)", "rgb(195, 251, 195)", +"hsl(150 87.5% 87.5%)", "rgb(195, 251, 223)", +"hsl(180 87.5% 87.5%)", "rgb(195, 251, 251)", +"hsl(210 87.5% 87.5%)", "rgb(195, 223, 251)", +"hsl(240 87.5% 87.5%)", "rgb(195, 195, 251)", +"hsl(270 87.5% 87.5%)", "rgb(223, 195, 251)", +"hsl(300 87.5% 87.5%)", "rgb(251, 195, 251)", +"hsl(330 87.5% 87.5%)", "rgb(251, 195, 223)", +"hsl(0 100% 87.5%)", "rgb(255, 191, 191)", +"hsl(30 100% 87.5%)", "rgb(255, 223, 191)", +"hsl(60 100% 87.5%)", "rgb(255, 255, 191)", +"hsl(90 100% 87.5%)", "rgb(223, 255, 191)", +"hsl(120 100% 87.5%)", "rgb(191, 255, 191)", +"hsl(150 100% 87.5%)", "rgb(191, 255, 223)", +"hsl(180 100% 87.5%)", "rgb(191, 255, 255)", +"hsl(210 100% 87.5%)", "rgb(191, 223, 255)", +"hsl(240 100% 87.5%)", "rgb(191, 191, 255)", +"hsl(270 100% 87.5%)", "rgb(223, 191, 255)", +"hsl(300 100% 87.5%)", "rgb(255, 191, 255)", +"hsl(330 100% 87.5%)", "rgb(255, 191, 223)", +"hsl(0 0% 100%)", "rgb(255, 255, 255)", +"hsl(30 0% 100%)", "rgb(255, 255, 255)", +"hsl(60 0% 100%)", "rgb(255, 255, 255)", +"hsl(90 0% 100%)", "rgb(255, 255, 255)", +"hsl(120 0% 100%)", "rgb(255, 255, 255)", +"hsl(150 0% 100%)", "rgb(255, 255, 255)", +"hsl(180 0% 100%)", "rgb(255, 255, 255)", +"hsl(210 0% 100%)", "rgb(255, 255, 255)", +"hsl(240 0% 100%)", "rgb(255, 255, 255)", +"hsl(270 0% 100%)", "rgb(255, 255, 255)", +"hsl(300 0% 100%)", "rgb(255, 255, 255)", +"hsl(330 0% 100%)", "rgb(255, 255, 255)", +"hsl(0 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(30 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(60 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(90 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(120 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(150 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(180 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(210 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(240 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(270 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(300 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(330 12.5% 100%)", "rgb(255, 255, 255)", +"hsl(0 25% 100%)", "rgb(255, 255, 255)", +"hsl(30 25% 100%)", "rgb(255, 255, 255)", +"hsl(60 25% 100%)", "rgb(255, 255, 255)", +"hsl(90 25% 100%)", "rgb(255, 255, 255)", +"hsl(120 25% 100%)", "rgb(255, 255, 255)", +"hsl(150 25% 100%)", "rgb(255, 255, 255)", +"hsl(180 25% 100%)", "rgb(255, 255, 255)", +"hsl(210 25% 100%)", "rgb(255, 255, 255)", +"hsl(240 25% 100%)", "rgb(255, 255, 255)", +"hsl(270 25% 100%)", "rgb(255, 255, 255)", +"hsl(300 25% 100%)", "rgb(255, 255, 255)", +"hsl(330 25% 100%)", "rgb(255, 255, 255)", +"hsl(0 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(30 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(60 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(90 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(120 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(150 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(180 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(210 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(240 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(270 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(300 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(330 37.5% 100%)", "rgb(255, 255, 255)", +"hsl(0 50% 100%)", "rgb(255, 255, 255)", +"hsl(30 50% 100%)", "rgb(255, 255, 255)", +"hsl(60 50% 100%)", "rgb(255, 255, 255)", +"hsl(90 50% 100%)", "rgb(255, 255, 255)", +"hsl(120 50% 100%)", "rgb(255, 255, 255)", +"hsl(150 50% 100%)", "rgb(255, 255, 255)", +"hsl(180 50% 100%)", "rgb(255, 255, 255)", +"hsl(210 50% 100%)", "rgb(255, 255, 255)", +"hsl(240 50% 100%)", "rgb(255, 255, 255)", +"hsl(270 50% 100%)", "rgb(255, 255, 255)", +"hsl(300 50% 100%)", "rgb(255, 255, 255)", +"hsl(330 50% 100%)", "rgb(255, 255, 255)", +"hsl(0 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(30 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(60 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(90 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(120 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(150 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(180 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(210 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(240 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(270 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(300 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(330 62.5% 100%)", "rgb(255, 255, 255)", +"hsl(0 75% 100%)", "rgb(255, 255, 255)", +"hsl(30 75% 100%)", "rgb(255, 255, 255)", +"hsl(60 75% 100%)", "rgb(255, 255, 255)", +"hsl(90 75% 100%)", "rgb(255, 255, 255)", +"hsl(120 75% 100%)", "rgb(255, 255, 255)", +"hsl(150 75% 100%)", "rgb(255, 255, 255)", +"hsl(180 75% 100%)", "rgb(255, 255, 255)", +"hsl(210 75% 100%)", "rgb(255, 255, 255)", +"hsl(240 75% 100%)", "rgb(255, 255, 255)", +"hsl(270 75% 100%)", "rgb(255, 255, 255)", +"hsl(300 75% 100%)", "rgb(255, 255, 255)", +"hsl(330 75% 100%)", "rgb(255, 255, 255)", +"hsl(0 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(30 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(60 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(90 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(120 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(150 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(180 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(210 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(240 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(270 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(300 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(330 87.5% 100%)", "rgb(255, 255, 255)", +"hsl(0 100% 100%)", "rgb(255, 255, 255)", +"hsl(30 100% 100%)", "rgb(255, 255, 255)", +"hsl(60 100% 100%)", "rgb(255, 255, 255)", +"hsl(90 100% 100%)", "rgb(255, 255, 255)", +"hsl(120 100% 100%)", "rgb(255, 255, 255)", +"hsl(150 100% 100%)", "rgb(255, 255, 255)", +"hsl(180 100% 100%)", "rgb(255, 255, 255)", +"hsl(210 100% 100%)", "rgb(255, 255, 255)", +"hsl(240 100% 100%)", "rgb(255, 255, 255)", +"hsl(270 100% 100%)", "rgb(255, 255, 255)", +"hsl(300 100% 100%)", "rgb(255, 255, 255)", +"hsl(330 100% 100%)", "rgb(255, 255, 255)", +"hsl(0 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(30 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(60 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(90 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(120 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(150 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(180 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(210 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(240 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(270 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(300 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(330 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsl(0 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(30 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(60 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(90 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(120 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(150 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(180 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(210 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(240 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(270 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(300 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(330 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsl(0 12.5% 12.5% / 1.0)", "rgb(36, 28, 28)", +"hsl(30 12.5% 12.5% / 1.0)", "rgb(36, 32, 28)", +"hsl(60 12.5% 12.5% / 1.0)", "rgb(36, 36, 28)", +"hsl(90 12.5% 12.5% / 1.0)", "rgb(32, 36, 28)", +"hsl(120 12.5% 12.5% / 1.0)", "rgb(28, 36, 28)", +"hsl(150 12.5% 12.5% / 1.0)", "rgb(28, 36, 32)", +"hsl(180 12.5% 12.5% / 1.0)", "rgb(28, 36, 36)", +"hsl(210 12.5% 12.5% / 1.0)", "rgb(28, 32, 36)", +"hsl(240 12.5% 12.5% / 1.0)", "rgb(28, 28, 36)", +"hsl(270 12.5% 12.5% / 1.0)", "rgb(32, 28, 36)", +"hsl(300 12.5% 12.5% / 1.0)", "rgb(36, 28, 36)", +"hsl(330 12.5% 12.5% / 1.0)", "rgb(36, 28, 32)", +"hsl(0 25% 12.5% / 1.0)", "rgb(40, 24, 24)", +"hsl(30 25% 12.5% / 1.0)", "rgb(40, 32, 24)", +"hsl(60 25% 12.5% / 1.0)", "rgb(40, 40, 24)", +"hsl(90 25% 12.5% / 1.0)", "rgb(32, 40, 24)", +"hsl(120 25% 12.5% / 1.0)", "rgb(24, 40, 24)", +"hsl(150 25% 12.5% / 1.0)", "rgb(24, 40, 32)", +"hsl(180 25% 12.5% / 1.0)", "rgb(24, 40, 40)", +"hsl(210 25% 12.5% / 1.0)", "rgb(24, 32, 40)", +"hsl(240 25% 12.5% / 1.0)", "rgb(24, 24, 40)", +"hsl(270 25% 12.5% / 1.0)", "rgb(32, 24, 40)", +"hsl(300 25% 12.5% / 1.0)", "rgb(40, 24, 40)", +"hsl(330 25% 12.5% / 1.0)", "rgb(40, 24, 32)", +"hsl(0 37.5% 12.5% / 1.0)", "rgb(44, 20, 20)", +"hsl(30 37.5% 12.5% / 1.0)", "rgb(44, 32, 20)", +"hsl(60 37.5% 12.5% / 1.0)", "rgb(44, 44, 20)", +"hsl(90 37.5% 12.5% / 1.0)", "rgb(32, 44, 20)", +"hsl(120 37.5% 12.5% / 1.0)", "rgb(20, 44, 20)", +"hsl(150 37.5% 12.5% / 1.0)", "rgb(20, 44, 32)", +"hsl(180 37.5% 12.5% / 1.0)", "rgb(20, 44, 44)", +"hsl(210 37.5% 12.5% / 1.0)", "rgb(20, 32, 44)", +"hsl(240 37.5% 12.5% / 1.0)", "rgb(20, 20, 44)", +"hsl(270 37.5% 12.5% / 1.0)", "rgb(32, 20, 44)", +"hsl(300 37.5% 12.5% / 1.0)", "rgb(44, 20, 44)", +"hsl(330 37.5% 12.5% / 1.0)", "rgb(44, 20, 32)", +"hsl(0 50% 12.5% / 1.0)", "rgb(48, 16, 16)", +"hsl(30 50% 12.5% / 1.0)", "rgb(48, 32, 16)", +"hsl(60 50% 12.5% / 1.0)", "rgb(48, 48, 16)", +"hsl(90 50% 12.5% / 1.0)", "rgb(32, 48, 16)", +"hsl(120 50% 12.5% / 1.0)", "rgb(16, 48, 16)", +"hsl(150 50% 12.5% / 1.0)", "rgb(16, 48, 32)", +"hsl(180 50% 12.5% / 1.0)", "rgb(16, 48, 48)", +"hsl(210 50% 12.5% / 1.0)", "rgb(16, 32, 48)", +"hsl(240 50% 12.5% / 1.0)", "rgb(16, 16, 48)", +"hsl(270 50% 12.5% / 1.0)", "rgb(32, 16, 48)", +"hsl(300 50% 12.5% / 1.0)", "rgb(48, 16, 48)", +"hsl(330 50% 12.5% / 1.0)", "rgb(48, 16, 32)", +"hsl(0 62.5% 12.5% / 1.0)", "rgb(52, 12, 12)", +"hsl(30 62.5% 12.5% / 1.0)", "rgb(52, 32, 12)", +"hsl(60 62.5% 12.5% / 1.0)", "rgb(52, 52, 12)", +"hsl(90 62.5% 12.5% / 1.0)", "rgb(32, 52, 12)", +"hsl(120 62.5% 12.5% / 1.0)", "rgb(12, 52, 12)", +"hsl(150 62.5% 12.5% / 1.0)", "rgb(12, 52, 32)", +"hsl(180 62.5% 12.5% / 1.0)", "rgb(12, 52, 52)", +"hsl(210 62.5% 12.5% / 1.0)", "rgb(12, 32, 52)", +"hsl(240 62.5% 12.5% / 1.0)", "rgb(12, 12, 52)", +"hsl(270 62.5% 12.5% / 1.0)", "rgb(32, 12, 52)", +"hsl(300 62.5% 12.5% / 1.0)", "rgb(52, 12, 52)", +"hsl(330 62.5% 12.5% / 1.0)", "rgb(52, 12, 32)", +"hsl(0 75% 12.5% / 1.0)", "rgb(56, 8, 8)", +"hsl(30 75% 12.5% / 1.0)", "rgb(56, 32, 8)", +"hsl(60 75% 12.5% / 1.0)", "rgb(56, 56, 8)", +"hsl(90 75% 12.5% / 1.0)", "rgb(32, 56, 8)", +"hsl(120 75% 12.5% / 1.0)", "rgb(8, 56, 8)", +"hsl(150 75% 12.5% / 1.0)", "rgb(8, 56, 32)", +"hsl(180 75% 12.5% / 1.0)", "rgb(8, 56, 56)", +"hsl(210 75% 12.5% / 1.0)", "rgb(8, 32, 56)", +"hsl(240 75% 12.5% / 1.0)", "rgb(8, 8, 56)", +"hsl(270 75% 12.5% / 1.0)", "rgb(32, 8, 56)", +"hsl(300 75% 12.5% / 1.0)", "rgb(56, 8, 56)", +"hsl(330 75% 12.5% / 1.0)", "rgb(56, 8, 32)", +"hsl(0 87.5% 12.5% / 1.0)", "rgb(60, 4, 4)", +"hsl(30 87.5% 12.5% / 1.0)", "rgb(60, 32, 4)", +"hsl(60 87.5% 12.5% / 1.0)", "rgb(60, 60, 4)", +"hsl(90 87.5% 12.5% / 1.0)", "rgb(32, 60, 4)", +"hsl(120 87.5% 12.5% / 1.0)", "rgb(4, 60, 4)", +"hsl(150 87.5% 12.5% / 1.0)", "rgb(4, 60, 32)", +"hsl(180 87.5% 12.5% / 1.0)", "rgb(4, 60, 60)", +"hsl(210 87.5% 12.5% / 1.0)", "rgb(4, 32, 60)", +"hsl(240 87.5% 12.5% / 1.0)", "rgb(4, 4, 60)", +"hsl(270 87.5% 12.5% / 1.0)", "rgb(32, 4, 60)", +"hsl(300 87.5% 12.5% / 1.0)", "rgb(60, 4, 60)", +"hsl(330 87.5% 12.5% / 1.0)", "rgb(60, 4, 32)", +"hsl(0 100% 12.5% / 1.0)", "rgb(64, 0, 0)", +"hsl(30 100% 12.5% / 1.0)", "rgb(64, 32, 0)", +"hsl(60 100% 12.5% / 1.0)", "rgb(64, 64, 0)", +"hsl(90 100% 12.5% / 1.0)", "rgb(32, 64, 0)", +"hsl(120 100% 12.5% / 1.0)", "rgb(0, 64, 0)", +"hsl(150 100% 12.5% / 1.0)", "rgb(0, 64, 32)", +"hsl(180 100% 12.5% / 1.0)", "rgb(0, 64, 64)", +"hsl(210 100% 12.5% / 1.0)", "rgb(0, 32, 64)", +"hsl(240 100% 12.5% / 1.0)", "rgb(0, 0, 64)", +"hsl(270 100% 12.5% / 1.0)", "rgb(32, 0, 64)", +"hsl(300 100% 12.5% / 1.0)", "rgb(64, 0, 64)", +"hsl(330 100% 12.5% / 1.0)", "rgb(64, 0, 32)", +"hsl(0 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(30 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(60 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(90 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(120 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(150 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(180 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(210 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(240 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(270 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(300 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(330 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsl(0 12.5% 25% / 1.0)", "rgb(72, 56, 56)", +"hsl(30 12.5% 25% / 1.0)", "rgb(72, 64, 56)", +"hsl(60 12.5% 25% / 1.0)", "rgb(72, 72, 56)", +"hsl(90 12.5% 25% / 1.0)", "rgb(64, 72, 56)", +"hsl(120 12.5% 25% / 1.0)", "rgb(56, 72, 56)", +"hsl(150 12.5% 25% / 1.0)", "rgb(56, 72, 64)", +"hsl(180 12.5% 25% / 1.0)", "rgb(56, 72, 72)", +"hsl(210 12.5% 25% / 1.0)", "rgb(56, 64, 72)", +"hsl(240 12.5% 25% / 1.0)", "rgb(56, 56, 72)", +"hsl(270 12.5% 25% / 1.0)", "rgb(64, 56, 72)", +"hsl(300 12.5% 25% / 1.0)", "rgb(72, 56, 72)", +"hsl(330 12.5% 25% / 1.0)", "rgb(72, 56, 64)", +"hsl(0 25% 25% / 1.0)", "rgb(80, 48, 48)", +"hsl(30 25% 25% / 1.0)", "rgb(80, 64, 48)", +"hsl(60 25% 25% / 1.0)", "rgb(80, 80, 48)", +"hsl(90 25% 25% / 1.0)", "rgb(64, 80, 48)", +"hsl(120 25% 25% / 1.0)", "rgb(48, 80, 48)", +"hsl(150 25% 25% / 1.0)", "rgb(48, 80, 64)", +"hsl(180 25% 25% / 1.0)", "rgb(48, 80, 80)", +"hsl(210 25% 25% / 1.0)", "rgb(48, 64, 80)", +"hsl(240 25% 25% / 1.0)", "rgb(48, 48, 80)", +"hsl(270 25% 25% / 1.0)", "rgb(64, 48, 80)", +"hsl(300 25% 25% / 1.0)", "rgb(80, 48, 80)", +"hsl(330 25% 25% / 1.0)", "rgb(80, 48, 64)", +"hsl(0 37.5% 25% / 1.0)", "rgb(88, 40, 40)", +"hsl(30 37.5% 25% / 1.0)", "rgb(88, 64, 40)", +"hsl(60 37.5% 25% / 1.0)", "rgb(88, 88, 40)", +"hsl(90 37.5% 25% / 1.0)", "rgb(64, 88, 40)", +"hsl(120 37.5% 25% / 1.0)", "rgb(40, 88, 40)", +"hsl(150 37.5% 25% / 1.0)", "rgb(40, 88, 64)", +"hsl(180 37.5% 25% / 1.0)", "rgb(40, 88, 88)", +"hsl(210 37.5% 25% / 1.0)", "rgb(40, 64, 88)", +"hsl(240 37.5% 25% / 1.0)", "rgb(40, 40, 88)", +"hsl(270 37.5% 25% / 1.0)", "rgb(64, 40, 88)", +"hsl(300 37.5% 25% / 1.0)", "rgb(88, 40, 88)", +"hsl(330 37.5% 25% / 1.0)", "rgb(88, 40, 64)", +"hsl(0 50% 25% / 1.0)", "rgb(96, 32, 32)", +"hsl(30 50% 25% / 1.0)", "rgb(96, 64, 32)", +"hsl(60 50% 25% / 1.0)", "rgb(96, 96, 32)", +"hsl(90 50% 25% / 1.0)", "rgb(64, 96, 32)", +"hsl(120 50% 25% / 1.0)", "rgb(32, 96, 32)", +"hsl(150 50% 25% / 1.0)", "rgb(32, 96, 64)", +"hsl(180 50% 25% / 1.0)", "rgb(32, 96, 96)", +"hsl(210 50% 25% / 1.0)", "rgb(32, 64, 96)", +"hsl(240 50% 25% / 1.0)", "rgb(32, 32, 96)", +"hsl(270 50% 25% / 1.0)", "rgb(64, 32, 96)", +"hsl(300 50% 25% / 1.0)", "rgb(96, 32, 96)", +"hsl(330 50% 25% / 1.0)", "rgb(96, 32, 64)", +"hsl(0 62.5% 25% / 1.0)", "rgb(104, 24, 24)", +"hsl(30 62.5% 25% / 1.0)", "rgb(104, 64, 24)", +"hsl(60 62.5% 25% / 1.0)", "rgb(104, 104, 24)", +"hsl(90 62.5% 25% / 1.0)", "rgb(64, 104, 24)", +"hsl(120 62.5% 25% / 1.0)", "rgb(24, 104, 24)", +"hsl(150 62.5% 25% / 1.0)", "rgb(24, 104, 64)", +"hsl(180 62.5% 25% / 1.0)", "rgb(24, 104, 104)", +"hsl(210 62.5% 25% / 1.0)", "rgb(24, 64, 104)", +"hsl(240 62.5% 25% / 1.0)", "rgb(24, 24, 104)", +"hsl(270 62.5% 25% / 1.0)", "rgb(64, 24, 104)", +"hsl(300 62.5% 25% / 1.0)", "rgb(104, 24, 104)", +"hsl(330 62.5% 25% / 1.0)", "rgb(104, 24, 64)", +"hsl(0 75% 25% / 1.0)", "rgb(112, 16, 16)", +"hsl(30 75% 25% / 1.0)", "rgb(112, 64, 16)", +"hsl(60 75% 25% / 1.0)", "rgb(112, 112, 16)", +"hsl(90 75% 25% / 1.0)", "rgb(64, 112, 16)", +"hsl(120 75% 25% / 1.0)", "rgb(16, 112, 16)", +"hsl(150 75% 25% / 1.0)", "rgb(16, 112, 64)", +"hsl(180 75% 25% / 1.0)", "rgb(16, 112, 112)", +"hsl(210 75% 25% / 1.0)", "rgb(16, 64, 112)", +"hsl(240 75% 25% / 1.0)", "rgb(16, 16, 112)", +"hsl(270 75% 25% / 1.0)", "rgb(64, 16, 112)", +"hsl(300 75% 25% / 1.0)", "rgb(112, 16, 112)", +"hsl(330 75% 25% / 1.0)", "rgb(112, 16, 64)", +"hsl(0 87.5% 25% / 1.0)", "rgb(120, 8, 8)", +"hsl(30 87.5% 25% / 1.0)", "rgb(120, 64, 8)", +"hsl(60 87.5% 25% / 1.0)", "rgb(120, 120, 8)", +"hsl(90 87.5% 25% / 1.0)", "rgb(64, 120, 8)", +"hsl(120 87.5% 25% / 1.0)", "rgb(8, 120, 8)", +"hsl(150 87.5% 25% / 1.0)", "rgb(8, 120, 64)", +"hsl(180 87.5% 25% / 1.0)", "rgb(8, 120, 120)", +"hsl(210 87.5% 25% / 1.0)", "rgb(8, 64, 120)", +"hsl(240 87.5% 25% / 1.0)", "rgb(8, 8, 120)", +"hsl(270 87.5% 25% / 1.0)", "rgb(64, 8, 120)", +"hsl(300 87.5% 25% / 1.0)", "rgb(120, 8, 120)", +"hsl(330 87.5% 25% / 1.0)", "rgb(120, 8, 64)", +"hsl(0 100% 25% / 1.0)", "rgb(128, 0, 0)", +"hsl(30 100% 25% / 1.0)", "rgb(128, 64, 0)", +"hsl(60 100% 25% / 1.0)", "rgb(128, 128, 0)", +"hsl(90 100% 25% / 1.0)", "rgb(64, 128, 0)", +"hsl(120 100% 25% / 1.0)", "rgb(0, 128, 0)", +"hsl(150 100% 25% / 1.0)", "rgb(0, 128, 64)", +"hsl(180 100% 25% / 1.0)", "rgb(0, 128, 128)", +"hsl(210 100% 25% / 1.0)", "rgb(0, 64, 128)", +"hsl(240 100% 25% / 1.0)", "rgb(0, 0, 128)", +"hsl(270 100% 25% / 1.0)", "rgb(64, 0, 128)", +"hsl(300 100% 25% / 1.0)", "rgb(128, 0, 128)", +"hsl(330 100% 25% / 1.0)", "rgb(128, 0, 64)", +"hsl(0 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(30 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(60 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(90 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(120 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(150 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(180 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(210 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(240 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(270 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(300 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(330 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsl(0 12.5% 37.5% / 1.0)", "rgb(108, 84, 84)", +"hsl(30 12.5% 37.5% / 1.0)", "rgb(108, 96, 84)", +"hsl(60 12.5% 37.5% / 1.0)", "rgb(108, 108, 84)", +"hsl(90 12.5% 37.5% / 1.0)", "rgb(96, 108, 84)", +"hsl(120 12.5% 37.5% / 1.0)", "rgb(84, 108, 84)", +"hsl(150 12.5% 37.5% / 1.0)", "rgb(84, 108, 96)", +"hsl(180 12.5% 37.5% / 1.0)", "rgb(84, 108, 108)", +"hsl(210 12.5% 37.5% / 1.0)", "rgb(84, 96, 108)", +"hsl(240 12.5% 37.5% / 1.0)", "rgb(84, 84, 108)", +"hsl(270 12.5% 37.5% / 1.0)", "rgb(96, 84, 108)", +"hsl(300 12.5% 37.5% / 1.0)", "rgb(108, 84, 108)", +"hsl(330 12.5% 37.5% / 1.0)", "rgb(108, 84, 96)", +"hsl(0 25% 37.5% / 1.0)", "rgb(120, 72, 72)", +"hsl(30 25% 37.5% / 1.0)", "rgb(120, 96, 72)", +"hsl(60 25% 37.5% / 1.0)", "rgb(120, 120, 72)", +"hsl(90 25% 37.5% / 1.0)", "rgb(96, 120, 72)", +"hsl(120 25% 37.5% / 1.0)", "rgb(72, 120, 72)", +"hsl(150 25% 37.5% / 1.0)", "rgb(72, 120, 96)", +"hsl(180 25% 37.5% / 1.0)", "rgb(72, 120, 120)", +"hsl(210 25% 37.5% / 1.0)", "rgb(72, 96, 120)", +"hsl(240 25% 37.5% / 1.0)", "rgb(72, 72, 120)", +"hsl(270 25% 37.5% / 1.0)", "rgb(96, 72, 120)", +"hsl(300 25% 37.5% / 1.0)", "rgb(120, 72, 120)", +"hsl(330 25% 37.5% / 1.0)", "rgb(120, 72, 96)", +"hsl(0 37.5% 37.5% / 1.0)", "rgb(131, 60, 60)", +"hsl(30 37.5% 37.5% / 1.0)", "rgb(131, 96, 60)", +"hsl(60 37.5% 37.5% / 1.0)", "rgb(131, 131, 60)", +"hsl(90 37.5% 37.5% / 1.0)", "rgb(96, 131, 60)", +"hsl(120 37.5% 37.5% / 1.0)", "rgb(60, 131, 60)", +"hsl(150 37.5% 37.5% / 1.0)", "rgb(60, 131, 96)", +"hsl(180 37.5% 37.5% / 1.0)", "rgb(60, 131, 131)", +"hsl(210 37.5% 37.5% / 1.0)", "rgb(60, 96, 131)", +"hsl(240 37.5% 37.5% / 1.0)", "rgb(60, 60, 131)", +"hsl(270 37.5% 37.5% / 1.0)", "rgb(96, 60, 131)", +"hsl(300 37.5% 37.5% / 1.0)", "rgb(131, 60, 131)", +"hsl(330 37.5% 37.5% / 1.0)", "rgb(131, 60, 96)", +"hsl(0 50% 37.5% / 1.0)", "rgb(143, 48, 48)", +"hsl(30 50% 37.5% / 1.0)", "rgb(143, 96, 48)", +"hsl(60 50% 37.5% / 1.0)", "rgb(143, 143, 48)", +"hsl(90 50% 37.5% / 1.0)", "rgb(96, 143, 48)", +"hsl(120 50% 37.5% / 1.0)", "rgb(48, 143, 48)", +"hsl(150 50% 37.5% / 1.0)", "rgb(48, 143, 96)", +"hsl(180 50% 37.5% / 1.0)", "rgb(48, 143, 143)", +"hsl(210 50% 37.5% / 1.0)", "rgb(48, 96, 143)", +"hsl(240 50% 37.5% / 1.0)", "rgb(48, 48, 143)", +"hsl(270 50% 37.5% / 1.0)", "rgb(96, 48, 143)", +"hsl(300 50% 37.5% / 1.0)", "rgb(143, 48, 143)", +"hsl(330 50% 37.5% / 1.0)", "rgb(143, 48, 96)", +"hsl(0 62.5% 37.5% / 1.0)", "rgb(155, 36, 36)", +"hsl(30 62.5% 37.5% / 1.0)", "rgb(155, 96, 36)", +"hsl(60 62.5% 37.5% / 1.0)", "rgb(155, 155, 36)", +"hsl(90 62.5% 37.5% / 1.0)", "rgb(96, 155, 36)", +"hsl(120 62.5% 37.5% / 1.0)", "rgb(36, 155, 36)", +"hsl(150 62.5% 37.5% / 1.0)", "rgb(36, 155, 96)", +"hsl(180 62.5% 37.5% / 1.0)", "rgb(36, 155, 155)", +"hsl(210 62.5% 37.5% / 1.0)", "rgb(36, 96, 155)", +"hsl(240 62.5% 37.5% / 1.0)", "rgb(36, 36, 155)", +"hsl(270 62.5% 37.5% / 1.0)", "rgb(96, 36, 155)", +"hsl(300 62.5% 37.5% / 1.0)", "rgb(155, 36, 155)", +"hsl(330 62.5% 37.5% / 1.0)", "rgb(155, 36, 96)", +"hsl(0 75% 37.5% / 1.0)", "rgb(167, 24, 24)", +"hsl(30 75% 37.5% / 1.0)", "rgb(167, 96, 24)", +"hsl(60 75% 37.5% / 1.0)", "rgb(167, 167, 24)", +"hsl(90 75% 37.5% / 1.0)", "rgb(96, 167, 24)", +"hsl(120 75% 37.5% / 1.0)", "rgb(24, 167, 24)", +"hsl(150 75% 37.5% / 1.0)", "rgb(24, 167, 96)", +"hsl(180 75% 37.5% / 1.0)", "rgb(24, 167, 167)", +"hsl(210 75% 37.5% / 1.0)", "rgb(24, 96, 167)", +"hsl(240 75% 37.5% / 1.0)", "rgb(24, 24, 167)", +"hsl(270 75% 37.5% / 1.0)", "rgb(96, 24, 167)", +"hsl(300 75% 37.5% / 1.0)", "rgb(167, 24, 167)", +"hsl(330 75% 37.5% / 1.0)", "rgb(167, 24, 96)", +"hsl(0 87.5% 37.5% / 1.0)", "rgb(179, 12, 12)", +"hsl(30 87.5% 37.5% / 1.0)", "rgb(179, 96, 12)", +"hsl(60 87.5% 37.5% / 1.0)", "rgb(179, 179, 12)", +"hsl(90 87.5% 37.5% / 1.0)", "rgb(96, 179, 12)", +"hsl(120 87.5% 37.5% / 1.0)", "rgb(12, 179, 12)", +"hsl(150 87.5% 37.5% / 1.0)", "rgb(12, 179, 96)", +"hsl(180 87.5% 37.5% / 1.0)", "rgb(12, 179, 179)", +"hsl(210 87.5% 37.5% / 1.0)", "rgb(12, 96, 179)", +"hsl(240 87.5% 37.5% / 1.0)", "rgb(12, 12, 179)", +"hsl(270 87.5% 37.5% / 1.0)", "rgb(96, 12, 179)", +"hsl(300 87.5% 37.5% / 1.0)", "rgb(179, 12, 179)", +"hsl(330 87.5% 37.5% / 1.0)", "rgb(179, 12, 96)", +"hsl(0 100% 37.5% / 1.0)", "rgb(191, 0, 0)", +"hsl(30 100% 37.5% / 1.0)", "rgb(191, 96, 0)", +"hsl(60 100% 37.5% / 1.0)", "rgb(191, 191, 0)", +"hsl(90 100% 37.5% / 1.0)", "rgb(96, 191, 0)", +"hsl(120 100% 37.5% / 1.0)", "rgb(0, 191, 0)", +"hsl(150 100% 37.5% / 1.0)", "rgb(0, 191, 96)", +"hsl(180 100% 37.5% / 1.0)", "rgb(0, 191, 191)", +"hsl(210 100% 37.5% / 1.0)", "rgb(0, 96, 191)", +"hsl(240 100% 37.5% / 1.0)", "rgb(0, 0, 191)", +"hsl(270 100% 37.5% / 1.0)", "rgb(96, 0, 191)", +"hsl(300 100% 37.5% / 1.0)", "rgb(191, 0, 191)", +"hsl(330 100% 37.5% / 1.0)", "rgb(191, 0, 96)", +"hsl(0 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(30 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(60 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(90 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(120 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(150 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(180 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(210 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(240 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(270 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(300 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(330 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsl(0 12.5% 50% / 1.0)", "rgb(143, 112, 112)", +"hsl(30 12.5% 50% / 1.0)", "rgb(143, 128, 112)", +"hsl(60 12.5% 50% / 1.0)", "rgb(143, 143, 112)", +"hsl(90 12.5% 50% / 1.0)", "rgb(128, 143, 112)", +"hsl(120 12.5% 50% / 1.0)", "rgb(112, 143, 112)", +"hsl(150 12.5% 50% / 1.0)", "rgb(112, 143, 128)", +"hsl(180 12.5% 50% / 1.0)", "rgb(112, 143, 143)", +"hsl(210 12.5% 50% / 1.0)", "rgb(112, 128, 143)", +"hsl(240 12.5% 50% / 1.0)", "rgb(112, 112, 143)", +"hsl(270 12.5% 50% / 1.0)", "rgb(128, 112, 143)", +"hsl(300 12.5% 50% / 1.0)", "rgb(143, 112, 143)", +"hsl(330 12.5% 50% / 1.0)", "rgb(143, 112, 128)", +"hsl(0 25% 50% / 1.0)", "rgb(159, 96, 96)", +"hsl(30 25% 50% / 1.0)", "rgb(159, 128, 96)", +"hsl(60 25% 50% / 1.0)", "rgb(159, 159, 96)", +"hsl(90 25% 50% / 1.0)", "rgb(128, 159, 96)", +"hsl(120 25% 50% / 1.0)", "rgb(96, 159, 96)", +"hsl(150 25% 50% / 1.0)", "rgb(96, 159, 128)", +"hsl(180 25% 50% / 1.0)", "rgb(96, 159, 159)", +"hsl(210 25% 50% / 1.0)", "rgb(96, 128, 159)", +"hsl(240 25% 50% / 1.0)", "rgb(96, 96, 159)", +"hsl(270 25% 50% / 1.0)", "rgb(128, 96, 159)", +"hsl(300 25% 50% / 1.0)", "rgb(159, 96, 159)", +"hsl(330 25% 50% / 1.0)", "rgb(159, 96, 128)", +"hsl(0 37.5% 50% / 1.0)", "rgb(175, 80, 80)", +"hsl(30 37.5% 50% / 1.0)", "rgb(175, 128, 80)", +"hsl(60 37.5% 50% / 1.0)", "rgb(175, 175, 80)", +"hsl(90 37.5% 50% / 1.0)", "rgb(128, 175, 80)", +"hsl(120 37.5% 50% / 1.0)", "rgb(80, 175, 80)", +"hsl(150 37.5% 50% / 1.0)", "rgb(80, 175, 128)", +"hsl(180 37.5% 50% / 1.0)", "rgb(80, 175, 175)", +"hsl(210 37.5% 50% / 1.0)", "rgb(80, 128, 175)", +"hsl(240 37.5% 50% / 1.0)", "rgb(80, 80, 175)", +"hsl(270 37.5% 50% / 1.0)", "rgb(128, 80, 175)", +"hsl(300 37.5% 50% / 1.0)", "rgb(175, 80, 175)", +"hsl(330 37.5% 50% / 1.0)", "rgb(175, 80, 128)", +"hsl(0 50% 50% / 1.0)", "rgb(191, 64, 64)", +"hsl(30 50% 50% / 1.0)", "rgb(191, 128, 64)", +"hsl(60 50% 50% / 1.0)", "rgb(191, 191, 64)", +"hsl(90 50% 50% / 1.0)", "rgb(128, 191, 64)", +"hsl(120 50% 50% / 1.0)", "rgb(64, 191, 64)", +"hsl(150 50% 50% / 1.0)", "rgb(64, 191, 128)", +"hsl(180 50% 50% / 1.0)", "rgb(64, 191, 191)", +"hsl(210 50% 50% / 1.0)", "rgb(64, 128, 191)", +"hsl(240 50% 50% / 1.0)", "rgb(64, 64, 191)", +"hsl(270 50% 50% / 1.0)", "rgb(128, 64, 191)", +"hsl(300 50% 50% / 1.0)", "rgb(191, 64, 191)", +"hsl(330 50% 50% / 1.0)", "rgb(191, 64, 128)", +"hsl(0 62.5% 50% / 1.0)", "rgb(207, 48, 48)", +"hsl(30 62.5% 50% / 1.0)", "rgb(207, 128, 48)", +"hsl(60 62.5% 50% / 1.0)", "rgb(207, 207, 48)", +"hsl(90 62.5% 50% / 1.0)", "rgb(128, 207, 48)", +"hsl(120 62.5% 50% / 1.0)", "rgb(48, 207, 48)", +"hsl(150 62.5% 50% / 1.0)", "rgb(48, 207, 128)", +"hsl(180 62.5% 50% / 1.0)", "rgb(48, 207, 207)", +"hsl(210 62.5% 50% / 1.0)", "rgb(48, 128, 207)", +"hsl(240 62.5% 50% / 1.0)", "rgb(48, 48, 207)", +"hsl(270 62.5% 50% / 1.0)", "rgb(128, 48, 207)", +"hsl(300 62.5% 50% / 1.0)", "rgb(207, 48, 207)", +"hsl(330 62.5% 50% / 1.0)", "rgb(207, 48, 128)", +"hsl(0 75% 50% / 1.0)", "rgb(223, 32, 32)", +"hsl(30 75% 50% / 1.0)", "rgb(223, 128, 32)", +"hsl(60 75% 50% / 1.0)", "rgb(223, 223, 32)", +"hsl(90 75% 50% / 1.0)", "rgb(128, 223, 32)", +"hsl(120 75% 50% / 1.0)", "rgb(32, 223, 32)", +"hsl(150 75% 50% / 1.0)", "rgb(32, 223, 128)", +"hsl(180 75% 50% / 1.0)", "rgb(32, 223, 223)", +"hsl(210 75% 50% / 1.0)", "rgb(32, 128, 223)", +"hsl(240 75% 50% / 1.0)", "rgb(32, 32, 223)", +"hsl(270 75% 50% / 1.0)", "rgb(128, 32, 223)", +"hsl(300 75% 50% / 1.0)", "rgb(223, 32, 223)", +"hsl(330 75% 50% / 1.0)", "rgb(223, 32, 128)", +"hsl(0 87.5% 50% / 1.0)", "rgb(239, 16, 16)", +"hsl(30 87.5% 50% / 1.0)", "rgb(239, 128, 16)", +"hsl(60 87.5% 50% / 1.0)", "rgb(239, 239, 16)", +"hsl(90 87.5% 50% / 1.0)", "rgb(128, 239, 16)", +"hsl(120 87.5% 50% / 1.0)", "rgb(16, 239, 16)", +"hsl(150 87.5% 50% / 1.0)", "rgb(16, 239, 128)", +"hsl(180 87.5% 50% / 1.0)", "rgb(16, 239, 239)", +"hsl(210 87.5% 50% / 1.0)", "rgb(16, 128, 239)", +"hsl(240 87.5% 50% / 1.0)", "rgb(16, 16, 239)", +"hsl(270 87.5% 50% / 1.0)", "rgb(128, 16, 239)", +"hsl(300 87.5% 50% / 1.0)", "rgb(239, 16, 239)", +"hsl(330 87.5% 50% / 1.0)", "rgb(239, 16, 128)", +"hsl(0 100% 50% / 1.0)", "rgb(255, 0, 0)", +"hsl(30 100% 50% / 1.0)", "rgb(255, 128, 0)", +"hsl(60 100% 50% / 1.0)", "rgb(255, 255, 0)", +"hsl(90 100% 50% / 1.0)", "rgb(128, 255, 0)", +"hsl(120 100% 50% / 1.0)", "rgb(0, 255, 0)", +"hsl(150 100% 50% / 1.0)", "rgb(0, 255, 128)", +"hsl(180 100% 50% / 1.0)", "rgb(0, 255, 255)", +"hsl(210 100% 50% / 1.0)", "rgb(0, 128, 255)", +"hsl(240 100% 50% / 1.0)", "rgb(0, 0, 255)", +"hsl(270 100% 50% / 1.0)", "rgb(128, 0, 255)", +"hsl(300 100% 50% / 1.0)", "rgb(255, 0, 255)", +"hsl(330 100% 50% / 1.0)", "rgb(255, 0, 128)", +"hsl(0 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(30 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(60 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(90 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(120 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(150 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(180 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(210 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(240 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(270 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(300 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(330 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsl(0 12.5% 62.5% / 1.0)", "rgb(171, 147, 147)", +"hsl(30 12.5% 62.5% / 1.0)", "rgb(171, 159, 147)", +"hsl(60 12.5% 62.5% / 1.0)", "rgb(171, 171, 147)", +"hsl(90 12.5% 62.5% / 1.0)", "rgb(159, 171, 147)", +"hsl(120 12.5% 62.5% / 1.0)", "rgb(147, 171, 147)", +"hsl(150 12.5% 62.5% / 1.0)", "rgb(147, 171, 159)", +"hsl(180 12.5% 62.5% / 1.0)", "rgb(147, 171, 171)", +"hsl(210 12.5% 62.5% / 1.0)", "rgb(147, 159, 171)", +"hsl(240 12.5% 62.5% / 1.0)", "rgb(147, 147, 171)", +"hsl(270 12.5% 62.5% / 1.0)", "rgb(159, 147, 171)", +"hsl(300 12.5% 62.5% / 1.0)", "rgb(171, 147, 171)", +"hsl(330 12.5% 62.5% / 1.0)", "rgb(171, 147, 159)", +"hsl(0 25% 62.5% / 1.0)", "rgb(183, 135, 135)", +"hsl(30 25% 62.5% / 1.0)", "rgb(183, 159, 135)", +"hsl(60 25% 62.5% / 1.0)", "rgb(183, 183, 135)", +"hsl(90 25% 62.5% / 1.0)", "rgb(159, 183, 135)", +"hsl(120 25% 62.5% / 1.0)", "rgb(135, 183, 135)", +"hsl(150 25% 62.5% / 1.0)", "rgb(135, 183, 159)", +"hsl(180 25% 62.5% / 1.0)", "rgb(135, 183, 183)", +"hsl(210 25% 62.5% / 1.0)", "rgb(135, 159, 183)", +"hsl(240 25% 62.5% / 1.0)", "rgb(135, 135, 183)", +"hsl(270 25% 62.5% / 1.0)", "rgb(159, 135, 183)", +"hsl(300 25% 62.5% / 1.0)", "rgb(183, 135, 183)", +"hsl(330 25% 62.5% / 1.0)", "rgb(183, 135, 159)", +"hsl(0 37.5% 62.5% / 1.0)", "rgb(195, 124, 124)", +"hsl(30 37.5% 62.5% / 1.0)", "rgb(195, 159, 124)", +"hsl(60 37.5% 62.5% / 1.0)", "rgb(195, 195, 124)", +"hsl(90 37.5% 62.5% / 1.0)", "rgb(159, 195, 124)", +"hsl(120 37.5% 62.5% / 1.0)", "rgb(124, 195, 124)", +"hsl(150 37.5% 62.5% / 1.0)", "rgb(124, 195, 159)", +"hsl(180 37.5% 62.5% / 1.0)", "rgb(124, 195, 195)", +"hsl(210 37.5% 62.5% / 1.0)", "rgb(124, 159, 195)", +"hsl(240 37.5% 62.5% / 1.0)", "rgb(124, 124, 195)", +"hsl(270 37.5% 62.5% / 1.0)", "rgb(159, 124, 195)", +"hsl(300 37.5% 62.5% / 1.0)", "rgb(195, 124, 195)", +"hsl(330 37.5% 62.5% / 1.0)", "rgb(195, 124, 159)", +"hsl(0 50% 62.5% / 1.0)", "rgb(207, 112, 112)", +"hsl(30 50% 62.5% / 1.0)", "rgb(207, 159, 112)", +"hsl(60 50% 62.5% / 1.0)", "rgb(207, 207, 112)", +"hsl(90 50% 62.5% / 1.0)", "rgb(159, 207, 112)", +"hsl(120 50% 62.5% / 1.0)", "rgb(112, 207, 112)", +"hsl(150 50% 62.5% / 1.0)", "rgb(112, 207, 159)", +"hsl(180 50% 62.5% / 1.0)", "rgb(112, 207, 207)", +"hsl(210 50% 62.5% / 1.0)", "rgb(112, 159, 207)", +"hsl(240 50% 62.5% / 1.0)", "rgb(112, 112, 207)", +"hsl(270 50% 62.5% / 1.0)", "rgb(159, 112, 207)", +"hsl(300 50% 62.5% / 1.0)", "rgb(207, 112, 207)", +"hsl(330 50% 62.5% / 1.0)", "rgb(207, 112, 159)", +"hsl(0 62.5% 62.5% / 1.0)", "rgb(219, 100, 100)", +"hsl(30 62.5% 62.5% / 1.0)", "rgb(219, 159, 100)", +"hsl(60 62.5% 62.5% / 1.0)", "rgb(219, 219, 100)", +"hsl(90 62.5% 62.5% / 1.0)", "rgb(159, 219, 100)", +"hsl(120 62.5% 62.5% / 1.0)", "rgb(100, 219, 100)", +"hsl(150 62.5% 62.5% / 1.0)", "rgb(100, 219, 159)", +"hsl(180 62.5% 62.5% / 1.0)", "rgb(100, 219, 219)", +"hsl(210 62.5% 62.5% / 1.0)", "rgb(100, 159, 219)", +"hsl(240 62.5% 62.5% / 1.0)", "rgb(100, 100, 219)", +"hsl(270 62.5% 62.5% / 1.0)", "rgb(159, 100, 219)", +"hsl(300 62.5% 62.5% / 1.0)", "rgb(219, 100, 219)", +"hsl(330 62.5% 62.5% / 1.0)", "rgb(219, 100, 159)", +"hsl(0 75% 62.5% / 1.0)", "rgb(231, 88, 88)", +"hsl(30 75% 62.5% / 1.0)", "rgb(231, 159, 88)", +"hsl(60 75% 62.5% / 1.0)", "rgb(231, 231, 88)", +"hsl(90 75% 62.5% / 1.0)", "rgb(159, 231, 88)", +"hsl(120 75% 62.5% / 1.0)", "rgb(88, 231, 88)", +"hsl(150 75% 62.5% / 1.0)", "rgb(88, 231, 159)", +"hsl(180 75% 62.5% / 1.0)", "rgb(88, 231, 231)", +"hsl(210 75% 62.5% / 1.0)", "rgb(88, 159, 231)", +"hsl(240 75% 62.5% / 1.0)", "rgb(88, 88, 231)", +"hsl(270 75% 62.5% / 1.0)", "rgb(159, 88, 231)", +"hsl(300 75% 62.5% / 1.0)", "rgb(231, 88, 231)", +"hsl(330 75% 62.5% / 1.0)", "rgb(231, 88, 159)", +"hsl(0 87.5% 62.5% / 1.0)", "rgb(243, 76, 76)", +"hsl(30 87.5% 62.5% / 1.0)", "rgb(243, 159, 76)", +"hsl(60 87.5% 62.5% / 1.0)", "rgb(243, 243, 76)", +"hsl(90 87.5% 62.5% / 1.0)", "rgb(159, 243, 76)", +"hsl(120 87.5% 62.5% / 1.0)", "rgb(76, 243, 76)", +"hsl(150 87.5% 62.5% / 1.0)", "rgb(76, 243, 159)", +"hsl(180 87.5% 62.5% / 1.0)", "rgb(76, 243, 243)", +"hsl(210 87.5% 62.5% / 1.0)", "rgb(76, 159, 243)", +"hsl(240 87.5% 62.5% / 1.0)", "rgb(76, 76, 243)", +"hsl(270 87.5% 62.5% / 1.0)", "rgb(159, 76, 243)", +"hsl(300 87.5% 62.5% / 1.0)", "rgb(243, 76, 243)", +"hsl(330 87.5% 62.5% / 1.0)", "rgb(243, 76, 159)", +"hsl(0 100% 62.5% / 1.0)", "rgb(255, 64, 64)", +"hsl(30 100% 62.5% / 1.0)", "rgb(255, 159, 64)", +"hsl(60 100% 62.5% / 1.0)", "rgb(255, 255, 64)", +"hsl(90 100% 62.5% / 1.0)", "rgb(159, 255, 64)", +"hsl(120 100% 62.5% / 1.0)", "rgb(64, 255, 64)", +"hsl(150 100% 62.5% / 1.0)", "rgb(64, 255, 159)", +"hsl(180 100% 62.5% / 1.0)", "rgb(64, 255, 255)", +"hsl(210 100% 62.5% / 1.0)", "rgb(64, 159, 255)", +"hsl(240 100% 62.5% / 1.0)", "rgb(64, 64, 255)", +"hsl(270 100% 62.5% / 1.0)", "rgb(159, 64, 255)", +"hsl(300 100% 62.5% / 1.0)", "rgb(255, 64, 255)", +"hsl(330 100% 62.5% / 1.0)", "rgb(255, 64, 159)", +"hsl(0 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(30 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(60 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(90 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(120 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(150 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(180 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(210 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(240 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(270 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(300 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(330 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsl(0 12.5% 75% / 1.0)", "rgb(199, 183, 183)", +"hsl(30 12.5% 75% / 1.0)", "rgb(199, 191, 183)", +"hsl(60 12.5% 75% / 1.0)", "rgb(199, 199, 183)", +"hsl(90 12.5% 75% / 1.0)", "rgb(191, 199, 183)", +"hsl(120 12.5% 75% / 1.0)", "rgb(183, 199, 183)", +"hsl(150 12.5% 75% / 1.0)", "rgb(183, 199, 191)", +"hsl(180 12.5% 75% / 1.0)", "rgb(183, 199, 199)", +"hsl(210 12.5% 75% / 1.0)", "rgb(183, 191, 199)", +"hsl(240 12.5% 75% / 1.0)", "rgb(183, 183, 199)", +"hsl(270 12.5% 75% / 1.0)", "rgb(191, 183, 199)", +"hsl(300 12.5% 75% / 1.0)", "rgb(199, 183, 199)", +"hsl(330 12.5% 75% / 1.0)", "rgb(199, 183, 191)", +"hsl(0 25% 75% / 1.0)", "rgb(207, 175, 175)", +"hsl(30 25% 75% / 1.0)", "rgb(207, 191, 175)", +"hsl(60 25% 75% / 1.0)", "rgb(207, 207, 175)", +"hsl(90 25% 75% / 1.0)", "rgb(191, 207, 175)", +"hsl(120 25% 75% / 1.0)", "rgb(175, 207, 175)", +"hsl(150 25% 75% / 1.0)", "rgb(175, 207, 191)", +"hsl(180 25% 75% / 1.0)", "rgb(175, 207, 207)", +"hsl(210 25% 75% / 1.0)", "rgb(175, 191, 207)", +"hsl(240 25% 75% / 1.0)", "rgb(175, 175, 207)", +"hsl(270 25% 75% / 1.0)", "rgb(191, 175, 207)", +"hsl(300 25% 75% / 1.0)", "rgb(207, 175, 207)", +"hsl(330 25% 75% / 1.0)", "rgb(207, 175, 191)", +"hsl(0 37.5% 75% / 1.0)", "rgb(215, 167, 167)", +"hsl(30 37.5% 75% / 1.0)", "rgb(215, 191, 167)", +"hsl(60 37.5% 75% / 1.0)", "rgb(215, 215, 167)", +"hsl(90 37.5% 75% / 1.0)", "rgb(191, 215, 167)", +"hsl(120 37.5% 75% / 1.0)", "rgb(167, 215, 167)", +"hsl(150 37.5% 75% / 1.0)", "rgb(167, 215, 191)", +"hsl(180 37.5% 75% / 1.0)", "rgb(167, 215, 215)", +"hsl(210 37.5% 75% / 1.0)", "rgb(167, 191, 215)", +"hsl(240 37.5% 75% / 1.0)", "rgb(167, 167, 215)", +"hsl(270 37.5% 75% / 1.0)", "rgb(191, 167, 215)", +"hsl(300 37.5% 75% / 1.0)", "rgb(215, 167, 215)", +"hsl(330 37.5% 75% / 1.0)", "rgb(215, 167, 191)", +"hsl(0 50% 75% / 1.0)", "rgb(223, 159, 159)", +"hsl(30 50% 75% / 1.0)", "rgb(223, 191, 159)", +"hsl(60 50% 75% / 1.0)", "rgb(223, 223, 159)", +"hsl(90 50% 75% / 1.0)", "rgb(191, 223, 159)", +"hsl(120 50% 75% / 1.0)", "rgb(159, 223, 159)", +"hsl(150 50% 75% / 1.0)", "rgb(159, 223, 191)", +"hsl(180 50% 75% / 1.0)", "rgb(159, 223, 223)", +"hsl(210 50% 75% / 1.0)", "rgb(159, 191, 223)", +"hsl(240 50% 75% / 1.0)", "rgb(159, 159, 223)", +"hsl(270 50% 75% / 1.0)", "rgb(191, 159, 223)", +"hsl(300 50% 75% / 1.0)", "rgb(223, 159, 223)", +"hsl(330 50% 75% / 1.0)", "rgb(223, 159, 191)", +"hsl(0 62.5% 75% / 1.0)", "rgb(231, 151, 151)", +"hsl(30 62.5% 75% / 1.0)", "rgb(231, 191, 151)", +"hsl(60 62.5% 75% / 1.0)", "rgb(231, 231, 151)", +"hsl(90 62.5% 75% / 1.0)", "rgb(191, 231, 151)", +"hsl(120 62.5% 75% / 1.0)", "rgb(151, 231, 151)", +"hsl(150 62.5% 75% / 1.0)", "rgb(151, 231, 191)", +"hsl(180 62.5% 75% / 1.0)", "rgb(151, 231, 231)", +"hsl(210 62.5% 75% / 1.0)", "rgb(151, 191, 231)", +"hsl(240 62.5% 75% / 1.0)", "rgb(151, 151, 231)", +"hsl(270 62.5% 75% / 1.0)", "rgb(191, 151, 231)", +"hsl(300 62.5% 75% / 1.0)", "rgb(231, 151, 231)", +"hsl(330 62.5% 75% / 1.0)", "rgb(231, 151, 191)", +"hsl(0 75% 75% / 1.0)", "rgb(239, 143, 143)", +"hsl(30 75% 75% / 1.0)", "rgb(239, 191, 143)", +"hsl(60 75% 75% / 1.0)", "rgb(239, 239, 143)", +"hsl(90 75% 75% / 1.0)", "rgb(191, 239, 143)", +"hsl(120 75% 75% / 1.0)", "rgb(143, 239, 143)", +"hsl(150 75% 75% / 1.0)", "rgb(143, 239, 191)", +"hsl(180 75% 75% / 1.0)", "rgb(143, 239, 239)", +"hsl(210 75% 75% / 1.0)", "rgb(143, 191, 239)", +"hsl(240 75% 75% / 1.0)", "rgb(143, 143, 239)", +"hsl(270 75% 75% / 1.0)", "rgb(191, 143, 239)", +"hsl(300 75% 75% / 1.0)", "rgb(239, 143, 239)", +"hsl(330 75% 75% / 1.0)", "rgb(239, 143, 191)", +"hsl(0 87.5% 75% / 1.0)", "rgb(247, 135, 135)", +"hsl(30 87.5% 75% / 1.0)", "rgb(247, 191, 135)", +"hsl(60 87.5% 75% / 1.0)", "rgb(247, 247, 135)", +"hsl(90 87.5% 75% / 1.0)", "rgb(191, 247, 135)", +"hsl(120 87.5% 75% / 1.0)", "rgb(135, 247, 135)", +"hsl(150 87.5% 75% / 1.0)", "rgb(135, 247, 191)", +"hsl(180 87.5% 75% / 1.0)", "rgb(135, 247, 247)", +"hsl(210 87.5% 75% / 1.0)", "rgb(135, 191, 247)", +"hsl(240 87.5% 75% / 1.0)", "rgb(135, 135, 247)", +"hsl(270 87.5% 75% / 1.0)", "rgb(191, 135, 247)", +"hsl(300 87.5% 75% / 1.0)", "rgb(247, 135, 247)", +"hsl(330 87.5% 75% / 1.0)", "rgb(247, 135, 191)", +"hsl(0 100% 75% / 1.0)", "rgb(255, 128, 128)", +"hsl(30 100% 75% / 1.0)", "rgb(255, 191, 128)", +"hsl(60 100% 75% / 1.0)", "rgb(255, 255, 128)", +"hsl(90 100% 75% / 1.0)", "rgb(191, 255, 128)", +"hsl(120 100% 75% / 1.0)", "rgb(128, 255, 128)", +"hsl(150 100% 75% / 1.0)", "rgb(128, 255, 191)", +"hsl(180 100% 75% / 1.0)", "rgb(128, 255, 255)", +"hsl(210 100% 75% / 1.0)", "rgb(128, 191, 255)", +"hsl(240 100% 75% / 1.0)", "rgb(128, 128, 255)", +"hsl(270 100% 75% / 1.0)", "rgb(191, 128, 255)", +"hsl(300 100% 75% / 1.0)", "rgb(255, 128, 255)", +"hsl(330 100% 75% / 1.0)", "rgb(255, 128, 191)", +"hsl(0 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(30 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(60 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(90 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(120 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(150 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(180 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(210 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(240 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(270 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(300 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(330 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsl(0 12.5% 87.5% / 1.0)", "rgb(227, 219, 219)", +"hsl(30 12.5% 87.5% / 1.0)", "rgb(227, 223, 219)", +"hsl(60 12.5% 87.5% / 1.0)", "rgb(227, 227, 219)", +"hsl(90 12.5% 87.5% / 1.0)", "rgb(223, 227, 219)", +"hsl(120 12.5% 87.5% / 1.0)", "rgb(219, 227, 219)", +"hsl(150 12.5% 87.5% / 1.0)", "rgb(219, 227, 223)", +"hsl(180 12.5% 87.5% / 1.0)", "rgb(219, 227, 227)", +"hsl(210 12.5% 87.5% / 1.0)", "rgb(219, 223, 227)", +"hsl(240 12.5% 87.5% / 1.0)", "rgb(219, 219, 227)", +"hsl(270 12.5% 87.5% / 1.0)", "rgb(223, 219, 227)", +"hsl(300 12.5% 87.5% / 1.0)", "rgb(227, 219, 227)", +"hsl(330 12.5% 87.5% / 1.0)", "rgb(227, 219, 223)", +"hsl(0 25% 87.5% / 1.0)", "rgb(231, 215, 215)", +"hsl(30 25% 87.5% / 1.0)", "rgb(231, 223, 215)", +"hsl(60 25% 87.5% / 1.0)", "rgb(231, 231, 215)", +"hsl(90 25% 87.5% / 1.0)", "rgb(223, 231, 215)", +"hsl(120 25% 87.5% / 1.0)", "rgb(215, 231, 215)", +"hsl(150 25% 87.5% / 1.0)", "rgb(215, 231, 223)", +"hsl(180 25% 87.5% / 1.0)", "rgb(215, 231, 231)", +"hsl(210 25% 87.5% / 1.0)", "rgb(215, 223, 231)", +"hsl(240 25% 87.5% / 1.0)", "rgb(215, 215, 231)", +"hsl(270 25% 87.5% / 1.0)", "rgb(223, 215, 231)", +"hsl(300 25% 87.5% / 1.0)", "rgb(231, 215, 231)", +"hsl(330 25% 87.5% / 1.0)", "rgb(231, 215, 223)", +"hsl(0 37.5% 87.5% / 1.0)", "rgb(235, 211, 211)", +"hsl(30 37.5% 87.5% / 1.0)", "rgb(235, 223, 211)", +"hsl(60 37.5% 87.5% / 1.0)", "rgb(235, 235, 211)", +"hsl(90 37.5% 87.5% / 1.0)", "rgb(223, 235, 211)", +"hsl(120 37.5% 87.5% / 1.0)", "rgb(211, 235, 211)", +"hsl(150 37.5% 87.5% / 1.0)", "rgb(211, 235, 223)", +"hsl(180 37.5% 87.5% / 1.0)", "rgb(211, 235, 235)", +"hsl(210 37.5% 87.5% / 1.0)", "rgb(211, 223, 235)", +"hsl(240 37.5% 87.5% / 1.0)", "rgb(211, 211, 235)", +"hsl(270 37.5% 87.5% / 1.0)", "rgb(223, 211, 235)", +"hsl(300 37.5% 87.5% / 1.0)", "rgb(235, 211, 235)", +"hsl(330 37.5% 87.5% / 1.0)", "rgb(235, 211, 223)", +"hsl(0 50% 87.5% / 1.0)", "rgb(239, 207, 207)", +"hsl(30 50% 87.5% / 1.0)", "rgb(239, 223, 207)", +"hsl(60 50% 87.5% / 1.0)", "rgb(239, 239, 207)", +"hsl(90 50% 87.5% / 1.0)", "rgb(223, 239, 207)", +"hsl(120 50% 87.5% / 1.0)", "rgb(207, 239, 207)", +"hsl(150 50% 87.5% / 1.0)", "rgb(207, 239, 223)", +"hsl(180 50% 87.5% / 1.0)", "rgb(207, 239, 239)", +"hsl(210 50% 87.5% / 1.0)", "rgb(207, 223, 239)", +"hsl(240 50% 87.5% / 1.0)", "rgb(207, 207, 239)", +"hsl(270 50% 87.5% / 1.0)", "rgb(223, 207, 239)", +"hsl(300 50% 87.5% / 1.0)", "rgb(239, 207, 239)", +"hsl(330 50% 87.5% / 1.0)", "rgb(239, 207, 223)", +"hsl(0 62.5% 87.5% / 1.0)", "rgb(243, 203, 203)", +"hsl(30 62.5% 87.5% / 1.0)", "rgb(243, 223, 203)", +"hsl(60 62.5% 87.5% / 1.0)", "rgb(243, 243, 203)", +"hsl(90 62.5% 87.5% / 1.0)", "rgb(223, 243, 203)", +"hsl(120 62.5% 87.5% / 1.0)", "rgb(203, 243, 203)", +"hsl(150 62.5% 87.5% / 1.0)", "rgb(203, 243, 223)", +"hsl(180 62.5% 87.5% / 1.0)", "rgb(203, 243, 243)", +"hsl(210 62.5% 87.5% / 1.0)", "rgb(203, 223, 243)", +"hsl(240 62.5% 87.5% / 1.0)", "rgb(203, 203, 243)", +"hsl(270 62.5% 87.5% / 1.0)", "rgb(223, 203, 243)", +"hsl(300 62.5% 87.5% / 1.0)", "rgb(243, 203, 243)", +"hsl(330 62.5% 87.5% / 1.0)", "rgb(243, 203, 223)", +"hsl(0 75% 87.5% / 1.0)", "rgb(247, 199, 199)", +"hsl(30 75% 87.5% / 1.0)", "rgb(247, 223, 199)", +"hsl(60 75% 87.5% / 1.0)", "rgb(247, 247, 199)", +"hsl(90 75% 87.5% / 1.0)", "rgb(223, 247, 199)", +"hsl(120 75% 87.5% / 1.0)", "rgb(199, 247, 199)", +"hsl(150 75% 87.5% / 1.0)", "rgb(199, 247, 223)", +"hsl(180 75% 87.5% / 1.0)", "rgb(199, 247, 247)", +"hsl(210 75% 87.5% / 1.0)", "rgb(199, 223, 247)", +"hsl(240 75% 87.5% / 1.0)", "rgb(199, 199, 247)", +"hsl(270 75% 87.5% / 1.0)", "rgb(223, 199, 247)", +"hsl(300 75% 87.5% / 1.0)", "rgb(247, 199, 247)", +"hsl(330 75% 87.5% / 1.0)", "rgb(247, 199, 223)", +"hsl(0 87.5% 87.5% / 1.0)", "rgb(251, 195, 195)", +"hsl(30 87.5% 87.5% / 1.0)", "rgb(251, 223, 195)", +"hsl(60 87.5% 87.5% / 1.0)", "rgb(251, 251, 195)", +"hsl(90 87.5% 87.5% / 1.0)", "rgb(223, 251, 195)", +"hsl(120 87.5% 87.5% / 1.0)", "rgb(195, 251, 195)", +"hsl(150 87.5% 87.5% / 1.0)", "rgb(195, 251, 223)", +"hsl(180 87.5% 87.5% / 1.0)", "rgb(195, 251, 251)", +"hsl(210 87.5% 87.5% / 1.0)", "rgb(195, 223, 251)", +"hsl(240 87.5% 87.5% / 1.0)", "rgb(195, 195, 251)", +"hsl(270 87.5% 87.5% / 1.0)", "rgb(223, 195, 251)", +"hsl(300 87.5% 87.5% / 1.0)", "rgb(251, 195, 251)", +"hsl(330 87.5% 87.5% / 1.0)", "rgb(251, 195, 223)", +"hsl(0 100% 87.5% / 1.0)", "rgb(255, 191, 191)", +"hsl(30 100% 87.5% / 1.0)", "rgb(255, 223, 191)", +"hsl(60 100% 87.5% / 1.0)", "rgb(255, 255, 191)", +"hsl(90 100% 87.5% / 1.0)", "rgb(223, 255, 191)", +"hsl(120 100% 87.5% / 1.0)", "rgb(191, 255, 191)", +"hsl(150 100% 87.5% / 1.0)", "rgb(191, 255, 223)", +"hsl(180 100% 87.5% / 1.0)", "rgb(191, 255, 255)", +"hsl(210 100% 87.5% / 1.0)", "rgb(191, 223, 255)", +"hsl(240 100% 87.5% / 1.0)", "rgb(191, 191, 255)", +"hsl(270 100% 87.5% / 1.0)", "rgb(223, 191, 255)", +"hsl(300 100% 87.5% / 1.0)", "rgb(255, 191, 255)", +"hsl(330 100% 87.5% / 1.0)", "rgb(255, 191, 223)", +"hsl(0 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(30 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(60 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(90 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(120 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(150 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(180 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(210 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(240 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(270 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(300 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(330 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsl(0 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(30 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(60 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(90 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(120 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(150 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(180 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(210 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(240 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(270 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(300 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(330 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsl(0 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(30 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(60 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(90 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(120 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(150 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(180 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(210 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(240 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(270 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(300 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(330 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsl(0 12.5% 12.5% / 0.25)", "rgba(36, 28, 28, 0.25)", +"hsl(30 12.5% 12.5% / 0.25)", "rgba(36, 32, 28, 0.25)", +"hsl(60 12.5% 12.5% / 0.25)", "rgba(36, 36, 28, 0.25)", +"hsl(90 12.5% 12.5% / 0.25)", "rgba(32, 36, 28, 0.25)", +"hsl(120 12.5% 12.5% / 0.25)", "rgba(28, 36, 28, 0.25)", +"hsl(150 12.5% 12.5% / 0.25)", "rgba(28, 36, 32, 0.25)", +"hsl(180 12.5% 12.5% / 0.25)", "rgba(28, 36, 36, 0.25)", +"hsl(210 12.5% 12.5% / 0.25)", "rgba(28, 32, 36, 0.25)", +"hsl(240 12.5% 12.5% / 0.25)", "rgba(28, 28, 36, 0.25)", +"hsl(270 12.5% 12.5% / 0.25)", "rgba(32, 28, 36, 0.25)", +"hsl(300 12.5% 12.5% / 0.25)", "rgba(36, 28, 36, 0.25)", +"hsl(330 12.5% 12.5% / 0.25)", "rgba(36, 28, 32, 0.25)", +"hsl(0 25% 12.5% / 0.25)", "rgba(40, 24, 24, 0.25)", +"hsl(30 25% 12.5% / 0.25)", "rgba(40, 32, 24, 0.25)", +"hsl(60 25% 12.5% / 0.25)", "rgba(40, 40, 24, 0.25)", +"hsl(90 25% 12.5% / 0.25)", "rgba(32, 40, 24, 0.25)", +"hsl(120 25% 12.5% / 0.25)", "rgba(24, 40, 24, 0.25)", +"hsl(150 25% 12.5% / 0.25)", "rgba(24, 40, 32, 0.25)", +"hsl(180 25% 12.5% / 0.25)", "rgba(24, 40, 40, 0.25)", +"hsl(210 25% 12.5% / 0.25)", "rgba(24, 32, 40, 0.25)", +"hsl(240 25% 12.5% / 0.25)", "rgba(24, 24, 40, 0.25)", +"hsl(270 25% 12.5% / 0.25)", "rgba(32, 24, 40, 0.25)", +"hsl(300 25% 12.5% / 0.25)", "rgba(40, 24, 40, 0.25)", +"hsl(330 25% 12.5% / 0.25)", "rgba(40, 24, 32, 0.25)", +"hsl(0 37.5% 12.5% / 0.25)", "rgba(44, 20, 20, 0.25)", +"hsl(30 37.5% 12.5% / 0.25)", "rgba(44, 32, 20, 0.25)", +"hsl(60 37.5% 12.5% / 0.25)", "rgba(44, 44, 20, 0.25)", +"hsl(90 37.5% 12.5% / 0.25)", "rgba(32, 44, 20, 0.25)", +"hsl(120 37.5% 12.5% / 0.25)", "rgba(20, 44, 20, 0.25)", +"hsl(150 37.5% 12.5% / 0.25)", "rgba(20, 44, 32, 0.25)", +"hsl(180 37.5% 12.5% / 0.25)", "rgba(20, 44, 44, 0.25)", +"hsl(210 37.5% 12.5% / 0.25)", "rgba(20, 32, 44, 0.25)", +"hsl(240 37.5% 12.5% / 0.25)", "rgba(20, 20, 44, 0.25)", +"hsl(270 37.5% 12.5% / 0.25)", "rgba(32, 20, 44, 0.25)", +"hsl(300 37.5% 12.5% / 0.25)", "rgba(44, 20, 44, 0.25)", +"hsl(330 37.5% 12.5% / 0.25)", "rgba(44, 20, 32, 0.25)", +"hsl(0 50% 12.5% / 0.25)", "rgba(48, 16, 16, 0.25)", +"hsl(30 50% 12.5% / 0.25)", "rgba(48, 32, 16, 0.25)", +"hsl(60 50% 12.5% / 0.25)", "rgba(48, 48, 16, 0.25)", +"hsl(90 50% 12.5% / 0.25)", "rgba(32, 48, 16, 0.25)", +"hsl(120 50% 12.5% / 0.25)", "rgba(16, 48, 16, 0.25)", +"hsl(150 50% 12.5% / 0.25)", "rgba(16, 48, 32, 0.25)", +"hsl(180 50% 12.5% / 0.25)", "rgba(16, 48, 48, 0.25)", +"hsl(210 50% 12.5% / 0.25)", "rgba(16, 32, 48, 0.25)", +"hsl(240 50% 12.5% / 0.25)", "rgba(16, 16, 48, 0.25)", +"hsl(270 50% 12.5% / 0.25)", "rgba(32, 16, 48, 0.25)", +"hsl(300 50% 12.5% / 0.25)", "rgba(48, 16, 48, 0.25)", +"hsl(330 50% 12.5% / 0.25)", "rgba(48, 16, 32, 0.25)", +"hsl(0 62.5% 12.5% / 0.25)", "rgba(52, 12, 12, 0.25)", +"hsl(30 62.5% 12.5% / 0.25)", "rgba(52, 32, 12, 0.25)", +"hsl(60 62.5% 12.5% / 0.25)", "rgba(52, 52, 12, 0.25)", +"hsl(90 62.5% 12.5% / 0.25)", "rgba(32, 52, 12, 0.25)", +"hsl(120 62.5% 12.5% / 0.25)", "rgba(12, 52, 12, 0.25)", +"hsl(150 62.5% 12.5% / 0.25)", "rgba(12, 52, 32, 0.25)", +"hsl(180 62.5% 12.5% / 0.25)", "rgba(12, 52, 52, 0.25)", +"hsl(210 62.5% 12.5% / 0.25)", "rgba(12, 32, 52, 0.25)", +"hsl(240 62.5% 12.5% / 0.25)", "rgba(12, 12, 52, 0.25)", +"hsl(270 62.5% 12.5% / 0.25)", "rgba(32, 12, 52, 0.25)", +"hsl(300 62.5% 12.5% / 0.25)", "rgba(52, 12, 52, 0.25)", +"hsl(330 62.5% 12.5% / 0.25)", "rgba(52, 12, 32, 0.25)", +"hsl(0 75% 12.5% / 0.25)", "rgba(56, 8, 8, 0.25)", +"hsl(30 75% 12.5% / 0.25)", "rgba(56, 32, 8, 0.25)", +"hsl(60 75% 12.5% / 0.25)", "rgba(56, 56, 8, 0.25)", +"hsl(90 75% 12.5% / 0.25)", "rgba(32, 56, 8, 0.25)", +"hsl(120 75% 12.5% / 0.25)", "rgba(8, 56, 8, 0.25)", +"hsl(150 75% 12.5% / 0.25)", "rgba(8, 56, 32, 0.25)", +"hsl(180 75% 12.5% / 0.25)", "rgba(8, 56, 56, 0.25)", +"hsl(210 75% 12.5% / 0.25)", "rgba(8, 32, 56, 0.25)", +"hsl(240 75% 12.5% / 0.25)", "rgba(8, 8, 56, 0.25)", +"hsl(270 75% 12.5% / 0.25)", "rgba(32, 8, 56, 0.25)", +"hsl(300 75% 12.5% / 0.25)", "rgba(56, 8, 56, 0.25)", +"hsl(330 75% 12.5% / 0.25)", "rgba(56, 8, 32, 0.25)", +"hsl(0 87.5% 12.5% / 0.25)", "rgba(60, 4, 4, 0.25)", +"hsl(30 87.5% 12.5% / 0.25)", "rgba(60, 32, 4, 0.25)", +"hsl(60 87.5% 12.5% / 0.25)", "rgba(60, 60, 4, 0.25)", +"hsl(90 87.5% 12.5% / 0.25)", "rgba(32, 60, 4, 0.25)", +"hsl(120 87.5% 12.5% / 0.25)", "rgba(4, 60, 4, 0.25)", +"hsl(150 87.5% 12.5% / 0.25)", "rgba(4, 60, 32, 0.25)", +"hsl(180 87.5% 12.5% / 0.25)", "rgba(4, 60, 60, 0.25)", +"hsl(210 87.5% 12.5% / 0.25)", "rgba(4, 32, 60, 0.25)", +"hsl(240 87.5% 12.5% / 0.25)", "rgba(4, 4, 60, 0.25)", +"hsl(270 87.5% 12.5% / 0.25)", "rgba(32, 4, 60, 0.25)", +"hsl(300 87.5% 12.5% / 0.25)", "rgba(60, 4, 60, 0.25)", +"hsl(330 87.5% 12.5% / 0.25)", "rgba(60, 4, 32, 0.25)", +"hsl(0 100% 12.5% / 0.25)", "rgba(64, 0, 0, 0.25)", +"hsl(30 100% 12.5% / 0.25)", "rgba(64, 32, 0, 0.25)", +"hsl(60 100% 12.5% / 0.25)", "rgba(64, 64, 0, 0.25)", +"hsl(90 100% 12.5% / 0.25)", "rgba(32, 64, 0, 0.25)", +"hsl(120 100% 12.5% / 0.25)", "rgba(0, 64, 0, 0.25)", +"hsl(150 100% 12.5% / 0.25)", "rgba(0, 64, 32, 0.25)", +"hsl(180 100% 12.5% / 0.25)", "rgba(0, 64, 64, 0.25)", +"hsl(210 100% 12.5% / 0.25)", "rgba(0, 32, 64, 0.25)", +"hsl(240 100% 12.5% / 0.25)", "rgba(0, 0, 64, 0.25)", +"hsl(270 100% 12.5% / 0.25)", "rgba(32, 0, 64, 0.25)", +"hsl(300 100% 12.5% / 0.25)", "rgba(64, 0, 64, 0.25)", +"hsl(330 100% 12.5% / 0.25)", "rgba(64, 0, 32, 0.25)", +"hsl(0 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(30 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(60 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(90 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(120 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(150 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(180 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(210 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(240 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(270 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(300 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(330 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsl(0 12.5% 25% / 0.25)", "rgba(72, 56, 56, 0.25)", +"hsl(30 12.5% 25% / 0.25)", "rgba(72, 64, 56, 0.25)", +"hsl(60 12.5% 25% / 0.25)", "rgba(72, 72, 56, 0.25)", +"hsl(90 12.5% 25% / 0.25)", "rgba(64, 72, 56, 0.25)", +"hsl(120 12.5% 25% / 0.25)", "rgba(56, 72, 56, 0.25)", +"hsl(150 12.5% 25% / 0.25)", "rgba(56, 72, 64, 0.25)", +"hsl(180 12.5% 25% / 0.25)", "rgba(56, 72, 72, 0.25)", +"hsl(210 12.5% 25% / 0.25)", "rgba(56, 64, 72, 0.25)", +"hsl(240 12.5% 25% / 0.25)", "rgba(56, 56, 72, 0.25)", +"hsl(270 12.5% 25% / 0.25)", "rgba(64, 56, 72, 0.25)", +"hsl(300 12.5% 25% / 0.25)", "rgba(72, 56, 72, 0.25)", +"hsl(330 12.5% 25% / 0.25)", "rgba(72, 56, 64, 0.25)", +"hsl(0 25% 25% / 0.25)", "rgba(80, 48, 48, 0.25)", +"hsl(30 25% 25% / 0.25)", "rgba(80, 64, 48, 0.25)", +"hsl(60 25% 25% / 0.25)", "rgba(80, 80, 48, 0.25)", +"hsl(90 25% 25% / 0.25)", "rgba(64, 80, 48, 0.25)", +"hsl(120 25% 25% / 0.25)", "rgba(48, 80, 48, 0.25)", +"hsl(150 25% 25% / 0.25)", "rgba(48, 80, 64, 0.25)", +"hsl(180 25% 25% / 0.25)", "rgba(48, 80, 80, 0.25)", +"hsl(210 25% 25% / 0.25)", "rgba(48, 64, 80, 0.25)", +"hsl(240 25% 25% / 0.25)", "rgba(48, 48, 80, 0.25)", +"hsl(270 25% 25% / 0.25)", "rgba(64, 48, 80, 0.25)", +"hsl(300 25% 25% / 0.25)", "rgba(80, 48, 80, 0.25)", +"hsl(330 25% 25% / 0.25)", "rgba(80, 48, 64, 0.25)", +"hsl(0 37.5% 25% / 0.25)", "rgba(88, 40, 40, 0.25)", +"hsl(30 37.5% 25% / 0.25)", "rgba(88, 64, 40, 0.25)", +"hsl(60 37.5% 25% / 0.25)", "rgba(88, 88, 40, 0.25)", +"hsl(90 37.5% 25% / 0.25)", "rgba(64, 88, 40, 0.25)", +"hsl(120 37.5% 25% / 0.25)", "rgba(40, 88, 40, 0.25)", +"hsl(150 37.5% 25% / 0.25)", "rgba(40, 88, 64, 0.25)", +"hsl(180 37.5% 25% / 0.25)", "rgba(40, 88, 88, 0.25)", +"hsl(210 37.5% 25% / 0.25)", "rgba(40, 64, 88, 0.25)", +"hsl(240 37.5% 25% / 0.25)", "rgba(40, 40, 88, 0.25)", +"hsl(270 37.5% 25% / 0.25)", "rgba(64, 40, 88, 0.25)", +"hsl(300 37.5% 25% / 0.25)", "rgba(88, 40, 88, 0.25)", +"hsl(330 37.5% 25% / 0.25)", "rgba(88, 40, 64, 0.25)", +"hsl(0 50% 25% / 0.25)", "rgba(96, 32, 32, 0.25)", +"hsl(30 50% 25% / 0.25)", "rgba(96, 64, 32, 0.25)", +"hsl(60 50% 25% / 0.25)", "rgba(96, 96, 32, 0.25)", +"hsl(90 50% 25% / 0.25)", "rgba(64, 96, 32, 0.25)", +"hsl(120 50% 25% / 0.25)", "rgba(32, 96, 32, 0.25)", +"hsl(150 50% 25% / 0.25)", "rgba(32, 96, 64, 0.25)", +"hsl(180 50% 25% / 0.25)", "rgba(32, 96, 96, 0.25)", +"hsl(210 50% 25% / 0.25)", "rgba(32, 64, 96, 0.25)", +"hsl(240 50% 25% / 0.25)", "rgba(32, 32, 96, 0.25)", +"hsl(270 50% 25% / 0.25)", "rgba(64, 32, 96, 0.25)", +"hsl(300 50% 25% / 0.25)", "rgba(96, 32, 96, 0.25)", +"hsl(330 50% 25% / 0.25)", "rgba(96, 32, 64, 0.25)", +"hsl(0 62.5% 25% / 0.25)", "rgba(104, 24, 24, 0.25)", +"hsl(30 62.5% 25% / 0.25)", "rgba(104, 64, 24, 0.25)", +"hsl(60 62.5% 25% / 0.25)", "rgba(104, 104, 24, 0.25)", +"hsl(90 62.5% 25% / 0.25)", "rgba(64, 104, 24, 0.25)", +"hsl(120 62.5% 25% / 0.25)", "rgba(24, 104, 24, 0.25)", +"hsl(150 62.5% 25% / 0.25)", "rgba(24, 104, 64, 0.25)", +"hsl(180 62.5% 25% / 0.25)", "rgba(24, 104, 104, 0.25)", +"hsl(210 62.5% 25% / 0.25)", "rgba(24, 64, 104, 0.25)", +"hsl(240 62.5% 25% / 0.25)", "rgba(24, 24, 104, 0.25)", +"hsl(270 62.5% 25% / 0.25)", "rgba(64, 24, 104, 0.25)", +"hsl(300 62.5% 25% / 0.25)", "rgba(104, 24, 104, 0.25)", +"hsl(330 62.5% 25% / 0.25)", "rgba(104, 24, 64, 0.25)", +"hsl(0 75% 25% / 0.25)", "rgba(112, 16, 16, 0.25)", +"hsl(30 75% 25% / 0.25)", "rgba(112, 64, 16, 0.25)", +"hsl(60 75% 25% / 0.25)", "rgba(112, 112, 16, 0.25)", +"hsl(90 75% 25% / 0.25)", "rgba(64, 112, 16, 0.25)", +"hsl(120 75% 25% / 0.25)", "rgba(16, 112, 16, 0.25)", +"hsl(150 75% 25% / 0.25)", "rgba(16, 112, 64, 0.25)", +"hsl(180 75% 25% / 0.25)", "rgba(16, 112, 112, 0.25)", +"hsl(210 75% 25% / 0.25)", "rgba(16, 64, 112, 0.25)", +"hsl(240 75% 25% / 0.25)", "rgba(16, 16, 112, 0.25)", +"hsl(270 75% 25% / 0.25)", "rgba(64, 16, 112, 0.25)", +"hsl(300 75% 25% / 0.25)", "rgba(112, 16, 112, 0.25)", +"hsl(330 75% 25% / 0.25)", "rgba(112, 16, 64, 0.25)", +"hsl(0 87.5% 25% / 0.25)", "rgba(120, 8, 8, 0.25)", +"hsl(30 87.5% 25% / 0.25)", "rgba(120, 64, 8, 0.25)", +"hsl(60 87.5% 25% / 0.25)", "rgba(120, 120, 8, 0.25)", +"hsl(90 87.5% 25% / 0.25)", "rgba(64, 120, 8, 0.25)", +"hsl(120 87.5% 25% / 0.25)", "rgba(8, 120, 8, 0.25)", +"hsl(150 87.5% 25% / 0.25)", "rgba(8, 120, 64, 0.25)", +"hsl(180 87.5% 25% / 0.25)", "rgba(8, 120, 120, 0.25)", +"hsl(210 87.5% 25% / 0.25)", "rgba(8, 64, 120, 0.25)", +"hsl(240 87.5% 25% / 0.25)", "rgba(8, 8, 120, 0.25)", +"hsl(270 87.5% 25% / 0.25)", "rgba(64, 8, 120, 0.25)", +"hsl(300 87.5% 25% / 0.25)", "rgba(120, 8, 120, 0.25)", +"hsl(330 87.5% 25% / 0.25)", "rgba(120, 8, 64, 0.25)", +"hsl(0 100% 25% / 0.25)", "rgba(128, 0, 0, 0.25)", +"hsl(30 100% 25% / 0.25)", "rgba(128, 64, 0, 0.25)", +"hsl(60 100% 25% / 0.25)", "rgba(128, 128, 0, 0.25)", +"hsl(90 100% 25% / 0.25)", "rgba(64, 128, 0, 0.25)", +"hsl(120 100% 25% / 0.25)", "rgba(0, 128, 0, 0.25)", +"hsl(150 100% 25% / 0.25)", "rgba(0, 128, 64, 0.25)", +"hsl(180 100% 25% / 0.25)", "rgba(0, 128, 128, 0.25)", +"hsl(210 100% 25% / 0.25)", "rgba(0, 64, 128, 0.25)", +"hsl(240 100% 25% / 0.25)", "rgba(0, 0, 128, 0.25)", +"hsl(270 100% 25% / 0.25)", "rgba(64, 0, 128, 0.25)", +"hsl(300 100% 25% / 0.25)", "rgba(128, 0, 128, 0.25)", +"hsl(330 100% 25% / 0.25)", "rgba(128, 0, 64, 0.25)", +"hsl(0 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(30 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(60 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(90 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(120 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(150 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(180 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(210 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(240 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(270 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(300 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(330 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsl(0 12.5% 37.5% / 0.25)", "rgba(108, 84, 84, 0.25)", +"hsl(30 12.5% 37.5% / 0.25)", "rgba(108, 96, 84, 0.25)", +"hsl(60 12.5% 37.5% / 0.25)", "rgba(108, 108, 84, 0.25)", +"hsl(90 12.5% 37.5% / 0.25)", "rgba(96, 108, 84, 0.25)", +"hsl(120 12.5% 37.5% / 0.25)", "rgba(84, 108, 84, 0.25)", +"hsl(150 12.5% 37.5% / 0.25)", "rgba(84, 108, 96, 0.25)", +"hsl(180 12.5% 37.5% / 0.25)", "rgba(84, 108, 108, 0.25)", +"hsl(210 12.5% 37.5% / 0.25)", "rgba(84, 96, 108, 0.25)", +"hsl(240 12.5% 37.5% / 0.25)", "rgba(84, 84, 108, 0.25)", +"hsl(270 12.5% 37.5% / 0.25)", "rgba(96, 84, 108, 0.25)", +"hsl(300 12.5% 37.5% / 0.25)", "rgba(108, 84, 108, 0.25)", +"hsl(330 12.5% 37.5% / 0.25)", "rgba(108, 84, 96, 0.25)", +"hsl(0 25% 37.5% / 0.25)", "rgba(120, 72, 72, 0.25)", +"hsl(30 25% 37.5% / 0.25)", "rgba(120, 96, 72, 0.25)", +"hsl(60 25% 37.5% / 0.25)", "rgba(120, 120, 72, 0.25)", +"hsl(90 25% 37.5% / 0.25)", "rgba(96, 120, 72, 0.25)", +"hsl(120 25% 37.5% / 0.25)", "rgba(72, 120, 72, 0.25)", +"hsl(150 25% 37.5% / 0.25)", "rgba(72, 120, 96, 0.25)", +"hsl(180 25% 37.5% / 0.25)", "rgba(72, 120, 120, 0.25)", +"hsl(210 25% 37.5% / 0.25)", "rgba(72, 96, 120, 0.25)", +"hsl(240 25% 37.5% / 0.25)", "rgba(72, 72, 120, 0.25)", +"hsl(270 25% 37.5% / 0.25)", "rgba(96, 72, 120, 0.25)", +"hsl(300 25% 37.5% / 0.25)", "rgba(120, 72, 120, 0.25)", +"hsl(330 25% 37.5% / 0.25)", "rgba(120, 72, 96, 0.25)", +"hsl(0 37.5% 37.5% / 0.25)", "rgba(131, 60, 60, 0.25)", +"hsl(30 37.5% 37.5% / 0.25)", "rgba(131, 96, 60, 0.25)", +"hsl(60 37.5% 37.5% / 0.25)", "rgba(131, 131, 60, 0.25)", +"hsl(90 37.5% 37.5% / 0.25)", "rgba(96, 131, 60, 0.25)", +"hsl(120 37.5% 37.5% / 0.25)", "rgba(60, 131, 60, 0.25)", +"hsl(150 37.5% 37.5% / 0.25)", "rgba(60, 131, 96, 0.25)", +"hsl(180 37.5% 37.5% / 0.25)", "rgba(60, 131, 131, 0.25)", +"hsl(210 37.5% 37.5% / 0.25)", "rgba(60, 96, 131, 0.25)", +"hsl(240 37.5% 37.5% / 0.25)", "rgba(60, 60, 131, 0.25)", +"hsl(270 37.5% 37.5% / 0.25)", "rgba(96, 60, 131, 0.25)", +"hsl(300 37.5% 37.5% / 0.25)", "rgba(131, 60, 131, 0.25)", +"hsl(330 37.5% 37.5% / 0.25)", "rgba(131, 60, 96, 0.25)", +"hsl(0 50% 37.5% / 0.25)", "rgba(143, 48, 48, 0.25)", +"hsl(30 50% 37.5% / 0.25)", "rgba(143, 96, 48, 0.25)", +"hsl(60 50% 37.5% / 0.25)", "rgba(143, 143, 48, 0.25)", +"hsl(90 50% 37.5% / 0.25)", "rgba(96, 143, 48, 0.25)", +"hsl(120 50% 37.5% / 0.25)", "rgba(48, 143, 48, 0.25)", +"hsl(150 50% 37.5% / 0.25)", "rgba(48, 143, 96, 0.25)", +"hsl(180 50% 37.5% / 0.25)", "rgba(48, 143, 143, 0.25)", +"hsl(210 50% 37.5% / 0.25)", "rgba(48, 96, 143, 0.25)", +"hsl(240 50% 37.5% / 0.25)", "rgba(48, 48, 143, 0.25)", +"hsl(270 50% 37.5% / 0.25)", "rgba(96, 48, 143, 0.25)", +"hsl(300 50% 37.5% / 0.25)", "rgba(143, 48, 143, 0.25)", +"hsl(330 50% 37.5% / 0.25)", "rgba(143, 48, 96, 0.25)", +"hsl(0 62.5% 37.5% / 0.25)", "rgba(155, 36, 36, 0.25)", +"hsl(30 62.5% 37.5% / 0.25)", "rgba(155, 96, 36, 0.25)", +"hsl(60 62.5% 37.5% / 0.25)", "rgba(155, 155, 36, 0.25)", +"hsl(90 62.5% 37.5% / 0.25)", "rgba(96, 155, 36, 0.25)", +"hsl(120 62.5% 37.5% / 0.25)", "rgba(36, 155, 36, 0.25)", +"hsl(150 62.5% 37.5% / 0.25)", "rgba(36, 155, 96, 0.25)", +"hsl(180 62.5% 37.5% / 0.25)", "rgba(36, 155, 155, 0.25)", +"hsl(210 62.5% 37.5% / 0.25)", "rgba(36, 96, 155, 0.25)", +"hsl(240 62.5% 37.5% / 0.25)", "rgba(36, 36, 155, 0.25)", +"hsl(270 62.5% 37.5% / 0.25)", "rgba(96, 36, 155, 0.25)", +"hsl(300 62.5% 37.5% / 0.25)", "rgba(155, 36, 155, 0.25)", +"hsl(330 62.5% 37.5% / 0.25)", "rgba(155, 36, 96, 0.25)", +"hsl(0 75% 37.5% / 0.25)", "rgba(167, 24, 24, 0.25)", +"hsl(30 75% 37.5% / 0.25)", "rgba(167, 96, 24, 0.25)", +"hsl(60 75% 37.5% / 0.25)", "rgba(167, 167, 24, 0.25)", +"hsl(90 75% 37.5% / 0.25)", "rgba(96, 167, 24, 0.25)", +"hsl(120 75% 37.5% / 0.25)", "rgba(24, 167, 24, 0.25)", +"hsl(150 75% 37.5% / 0.25)", "rgba(24, 167, 96, 0.25)", +"hsl(180 75% 37.5% / 0.25)", "rgba(24, 167, 167, 0.25)", +"hsl(210 75% 37.5% / 0.25)", "rgba(24, 96, 167, 0.25)", +"hsl(240 75% 37.5% / 0.25)", "rgba(24, 24, 167, 0.25)", +"hsl(270 75% 37.5% / 0.25)", "rgba(96, 24, 167, 0.25)", +"hsl(300 75% 37.5% / 0.25)", "rgba(167, 24, 167, 0.25)", +"hsl(330 75% 37.5% / 0.25)", "rgba(167, 24, 96, 0.25)", +"hsl(0 87.5% 37.5% / 0.25)", "rgba(179, 12, 12, 0.25)", +"hsl(30 87.5% 37.5% / 0.25)", "rgba(179, 96, 12, 0.25)", +"hsl(60 87.5% 37.5% / 0.25)", "rgba(179, 179, 12, 0.25)", +"hsl(90 87.5% 37.5% / 0.25)", "rgba(96, 179, 12, 0.25)", +"hsl(120 87.5% 37.5% / 0.25)", "rgba(12, 179, 12, 0.25)", +"hsl(150 87.5% 37.5% / 0.25)", "rgba(12, 179, 96, 0.25)", +"hsl(180 87.5% 37.5% / 0.25)", "rgba(12, 179, 179, 0.25)", +"hsl(210 87.5% 37.5% / 0.25)", "rgba(12, 96, 179, 0.25)", +"hsl(240 87.5% 37.5% / 0.25)", "rgba(12, 12, 179, 0.25)", +"hsl(270 87.5% 37.5% / 0.25)", "rgba(96, 12, 179, 0.25)", +"hsl(300 87.5% 37.5% / 0.25)", "rgba(179, 12, 179, 0.25)", +"hsl(330 87.5% 37.5% / 0.25)", "rgba(179, 12, 96, 0.25)", +"hsl(0 100% 37.5% / 0.25)", "rgba(191, 0, 0, 0.25)", +"hsl(30 100% 37.5% / 0.25)", "rgba(191, 96, 0, 0.25)", +"hsl(60 100% 37.5% / 0.25)", "rgba(191, 191, 0, 0.25)", +"hsl(90 100% 37.5% / 0.25)", "rgba(96, 191, 0, 0.25)", +"hsl(120 100% 37.5% / 0.25)", "rgba(0, 191, 0, 0.25)", +"hsl(150 100% 37.5% / 0.25)", "rgba(0, 191, 96, 0.25)", +"hsl(180 100% 37.5% / 0.25)", "rgba(0, 191, 191, 0.25)", +"hsl(210 100% 37.5% / 0.25)", "rgba(0, 96, 191, 0.25)", +"hsl(240 100% 37.5% / 0.25)", "rgba(0, 0, 191, 0.25)", +"hsl(270 100% 37.5% / 0.25)", "rgba(96, 0, 191, 0.25)", +"hsl(300 100% 37.5% / 0.25)", "rgba(191, 0, 191, 0.25)", +"hsl(330 100% 37.5% / 0.25)", "rgba(191, 0, 96, 0.25)", +"hsl(0 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(30 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(60 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(90 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(120 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(150 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(180 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(210 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(240 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(270 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(300 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(330 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsl(0 12.5% 50% / 0.25)", "rgba(143, 112, 112, 0.25)", +"hsl(30 12.5% 50% / 0.25)", "rgba(143, 128, 112, 0.25)", +"hsl(60 12.5% 50% / 0.25)", "rgba(143, 143, 112, 0.25)", +"hsl(90 12.5% 50% / 0.25)", "rgba(128, 143, 112, 0.25)", +"hsl(120 12.5% 50% / 0.25)", "rgba(112, 143, 112, 0.25)", +"hsl(150 12.5% 50% / 0.25)", "rgba(112, 143, 128, 0.25)", +"hsl(180 12.5% 50% / 0.25)", "rgba(112, 143, 143, 0.25)", +"hsl(210 12.5% 50% / 0.25)", "rgba(112, 128, 143, 0.25)", +"hsl(240 12.5% 50% / 0.25)", "rgba(112, 112, 143, 0.25)", +"hsl(270 12.5% 50% / 0.25)", "rgba(128, 112, 143, 0.25)", +"hsl(300 12.5% 50% / 0.25)", "rgba(143, 112, 143, 0.25)", +"hsl(330 12.5% 50% / 0.25)", "rgba(143, 112, 128, 0.25)", +"hsl(0 25% 50% / 0.25)", "rgba(159, 96, 96, 0.25)", +"hsl(30 25% 50% / 0.25)", "rgba(159, 128, 96, 0.25)", +"hsl(60 25% 50% / 0.25)", "rgba(159, 159, 96, 0.25)", +"hsl(90 25% 50% / 0.25)", "rgba(128, 159, 96, 0.25)", +"hsl(120 25% 50% / 0.25)", "rgba(96, 159, 96, 0.25)", +"hsl(150 25% 50% / 0.25)", "rgba(96, 159, 128, 0.25)", +"hsl(180 25% 50% / 0.25)", "rgba(96, 159, 159, 0.25)", +"hsl(210 25% 50% / 0.25)", "rgba(96, 128, 159, 0.25)", +"hsl(240 25% 50% / 0.25)", "rgba(96, 96, 159, 0.25)", +"hsl(270 25% 50% / 0.25)", "rgba(128, 96, 159, 0.25)", +"hsl(300 25% 50% / 0.25)", "rgba(159, 96, 159, 0.25)", +"hsl(330 25% 50% / 0.25)", "rgba(159, 96, 128, 0.25)", +"hsl(0 37.5% 50% / 0.25)", "rgba(175, 80, 80, 0.25)", +"hsl(30 37.5% 50% / 0.25)", "rgba(175, 128, 80, 0.25)", +"hsl(60 37.5% 50% / 0.25)", "rgba(175, 175, 80, 0.25)", +"hsl(90 37.5% 50% / 0.25)", "rgba(128, 175, 80, 0.25)", +"hsl(120 37.5% 50% / 0.25)", "rgba(80, 175, 80, 0.25)", +"hsl(150 37.5% 50% / 0.25)", "rgba(80, 175, 128, 0.25)", +"hsl(180 37.5% 50% / 0.25)", "rgba(80, 175, 175, 0.25)", +"hsl(210 37.5% 50% / 0.25)", "rgba(80, 128, 175, 0.25)", +"hsl(240 37.5% 50% / 0.25)", "rgba(80, 80, 175, 0.25)", +"hsl(270 37.5% 50% / 0.25)", "rgba(128, 80, 175, 0.25)", +"hsl(300 37.5% 50% / 0.25)", "rgba(175, 80, 175, 0.25)", +"hsl(330 37.5% 50% / 0.25)", "rgba(175, 80, 128, 0.25)", +"hsl(0 50% 50% / 0.25)", "rgba(191, 64, 64, 0.25)", +"hsl(30 50% 50% / 0.25)", "rgba(191, 128, 64, 0.25)", +"hsl(60 50% 50% / 0.25)", "rgba(191, 191, 64, 0.25)", +"hsl(90 50% 50% / 0.25)", "rgba(128, 191, 64, 0.25)", +"hsl(120 50% 50% / 0.25)", "rgba(64, 191, 64, 0.25)", +"hsl(150 50% 50% / 0.25)", "rgba(64, 191, 128, 0.25)", +"hsl(180 50% 50% / 0.25)", "rgba(64, 191, 191, 0.25)", +"hsl(210 50% 50% / 0.25)", "rgba(64, 128, 191, 0.25)", +"hsl(240 50% 50% / 0.25)", "rgba(64, 64, 191, 0.25)", +"hsl(270 50% 50% / 0.25)", "rgba(128, 64, 191, 0.25)", +"hsl(300 50% 50% / 0.25)", "rgba(191, 64, 191, 0.25)", +"hsl(330 50% 50% / 0.25)", "rgba(191, 64, 128, 0.25)", +"hsl(0 62.5% 50% / 0.25)", "rgba(207, 48, 48, 0.25)", +"hsl(30 62.5% 50% / 0.25)", "rgba(207, 128, 48, 0.25)", +"hsl(60 62.5% 50% / 0.25)", "rgba(207, 207, 48, 0.25)", +"hsl(90 62.5% 50% / 0.25)", "rgba(128, 207, 48, 0.25)", +"hsl(120 62.5% 50% / 0.25)", "rgba(48, 207, 48, 0.25)", +"hsl(150 62.5% 50% / 0.25)", "rgba(48, 207, 128, 0.25)", +"hsl(180 62.5% 50% / 0.25)", "rgba(48, 207, 207, 0.25)", +"hsl(210 62.5% 50% / 0.25)", "rgba(48, 128, 207, 0.25)", +"hsl(240 62.5% 50% / 0.25)", "rgba(48, 48, 207, 0.25)", +"hsl(270 62.5% 50% / 0.25)", "rgba(128, 48, 207, 0.25)", +"hsl(300 62.5% 50% / 0.25)", "rgba(207, 48, 207, 0.25)", +"hsl(330 62.5% 50% / 0.25)", "rgba(207, 48, 128, 0.25)", +"hsl(0 75% 50% / 0.25)", "rgba(223, 32, 32, 0.25)", +"hsl(30 75% 50% / 0.25)", "rgba(223, 128, 32, 0.25)", +"hsl(60 75% 50% / 0.25)", "rgba(223, 223, 32, 0.25)", +"hsl(90 75% 50% / 0.25)", "rgba(128, 223, 32, 0.25)", +"hsl(120 75% 50% / 0.25)", "rgba(32, 223, 32, 0.25)", +"hsl(150 75% 50% / 0.25)", "rgba(32, 223, 128, 0.25)", +"hsl(180 75% 50% / 0.25)", "rgba(32, 223, 223, 0.25)", +"hsl(210 75% 50% / 0.25)", "rgba(32, 128, 223, 0.25)", +"hsl(240 75% 50% / 0.25)", "rgba(32, 32, 223, 0.25)", +"hsl(270 75% 50% / 0.25)", "rgba(128, 32, 223, 0.25)", +"hsl(300 75% 50% / 0.25)", "rgba(223, 32, 223, 0.25)", +"hsl(330 75% 50% / 0.25)", "rgba(223, 32, 128, 0.25)", +"hsl(0 87.5% 50% / 0.25)", "rgba(239, 16, 16, 0.25)", +"hsl(30 87.5% 50% / 0.25)", "rgba(239, 128, 16, 0.25)", +"hsl(60 87.5% 50% / 0.25)", "rgba(239, 239, 16, 0.25)", +"hsl(90 87.5% 50% / 0.25)", "rgba(128, 239, 16, 0.25)", +"hsl(120 87.5% 50% / 0.25)", "rgba(16, 239, 16, 0.25)", +"hsl(150 87.5% 50% / 0.25)", "rgba(16, 239, 128, 0.25)", +"hsl(180 87.5% 50% / 0.25)", "rgba(16, 239, 239, 0.25)", +"hsl(210 87.5% 50% / 0.25)", "rgba(16, 128, 239, 0.25)", +"hsl(240 87.5% 50% / 0.25)", "rgba(16, 16, 239, 0.25)", +"hsl(270 87.5% 50% / 0.25)", "rgba(128, 16, 239, 0.25)", +"hsl(300 87.5% 50% / 0.25)", "rgba(239, 16, 239, 0.25)", +"hsl(330 87.5% 50% / 0.25)", "rgba(239, 16, 128, 0.25)", +"hsl(0 100% 50% / 0.25)", "rgba(255, 0, 0, 0.25)", +"hsl(30 100% 50% / 0.25)", "rgba(255, 128, 0, 0.25)", +"hsl(60 100% 50% / 0.25)", "rgba(255, 255, 0, 0.25)", +"hsl(90 100% 50% / 0.25)", "rgba(128, 255, 0, 0.25)", +"hsl(120 100% 50% / 0.25)", "rgba(0, 255, 0, 0.25)", +"hsl(150 100% 50% / 0.25)", "rgba(0, 255, 128, 0.25)", +"hsl(180 100% 50% / 0.25)", "rgba(0, 255, 255, 0.25)", +"hsl(210 100% 50% / 0.25)", "rgba(0, 128, 255, 0.25)", +"hsl(240 100% 50% / 0.25)", "rgba(0, 0, 255, 0.25)", +"hsl(270 100% 50% / 0.25)", "rgba(128, 0, 255, 0.25)", +"hsl(300 100% 50% / 0.25)", "rgba(255, 0, 255, 0.25)", +"hsl(330 100% 50% / 0.25)", "rgba(255, 0, 128, 0.25)", +"hsl(0 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(30 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(60 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(90 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(120 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(150 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(180 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(210 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(240 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(270 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(300 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(330 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsl(0 12.5% 62.5% / 0.25)", "rgba(171, 147, 147, 0.25)", +"hsl(30 12.5% 62.5% / 0.25)", "rgba(171, 159, 147, 0.25)", +"hsl(60 12.5% 62.5% / 0.25)", "rgba(171, 171, 147, 0.25)", +"hsl(90 12.5% 62.5% / 0.25)", "rgba(159, 171, 147, 0.25)", +"hsl(120 12.5% 62.5% / 0.25)", "rgba(147, 171, 147, 0.25)", +"hsl(150 12.5% 62.5% / 0.25)", "rgba(147, 171, 159, 0.25)", +"hsl(180 12.5% 62.5% / 0.25)", "rgba(147, 171, 171, 0.25)", +"hsl(210 12.5% 62.5% / 0.25)", "rgba(147, 159, 171, 0.25)", +"hsl(240 12.5% 62.5% / 0.25)", "rgba(147, 147, 171, 0.25)", +"hsl(270 12.5% 62.5% / 0.25)", "rgba(159, 147, 171, 0.25)", +"hsl(300 12.5% 62.5% / 0.25)", "rgba(171, 147, 171, 0.25)", +"hsl(330 12.5% 62.5% / 0.25)", "rgba(171, 147, 159, 0.25)", +"hsl(0 25% 62.5% / 0.25)", "rgba(183, 135, 135, 0.25)", +"hsl(30 25% 62.5% / 0.25)", "rgba(183, 159, 135, 0.25)", +"hsl(60 25% 62.5% / 0.25)", "rgba(183, 183, 135, 0.25)", +"hsl(90 25% 62.5% / 0.25)", "rgba(159, 183, 135, 0.25)", +"hsl(120 25% 62.5% / 0.25)", "rgba(135, 183, 135, 0.25)", +"hsl(150 25% 62.5% / 0.25)", "rgba(135, 183, 159, 0.25)", +"hsl(180 25% 62.5% / 0.25)", "rgba(135, 183, 183, 0.25)", +"hsl(210 25% 62.5% / 0.25)", "rgba(135, 159, 183, 0.25)", +"hsl(240 25% 62.5% / 0.25)", "rgba(135, 135, 183, 0.25)", +"hsl(270 25% 62.5% / 0.25)", "rgba(159, 135, 183, 0.25)", +"hsl(300 25% 62.5% / 0.25)", "rgba(183, 135, 183, 0.25)", +"hsl(330 25% 62.5% / 0.25)", "rgba(183, 135, 159, 0.25)", +"hsl(0 37.5% 62.5% / 0.25)", "rgba(195, 124, 124, 0.25)", +"hsl(30 37.5% 62.5% / 0.25)", "rgba(195, 159, 124, 0.25)", +"hsl(60 37.5% 62.5% / 0.25)", "rgba(195, 195, 124, 0.25)", +"hsl(90 37.5% 62.5% / 0.25)", "rgba(159, 195, 124, 0.25)", +"hsl(120 37.5% 62.5% / 0.25)", "rgba(124, 195, 124, 0.25)", +"hsl(150 37.5% 62.5% / 0.25)", "rgba(124, 195, 159, 0.25)", +"hsl(180 37.5% 62.5% / 0.25)", "rgba(124, 195, 195, 0.25)", +"hsl(210 37.5% 62.5% / 0.25)", "rgba(124, 159, 195, 0.25)", +"hsl(240 37.5% 62.5% / 0.25)", "rgba(124, 124, 195, 0.25)", +"hsl(270 37.5% 62.5% / 0.25)", "rgba(159, 124, 195, 0.25)", +"hsl(300 37.5% 62.5% / 0.25)", "rgba(195, 124, 195, 0.25)", +"hsl(330 37.5% 62.5% / 0.25)", "rgba(195, 124, 159, 0.25)", +"hsl(0 50% 62.5% / 0.25)", "rgba(207, 112, 112, 0.25)", +"hsl(30 50% 62.5% / 0.25)", "rgba(207, 159, 112, 0.25)", +"hsl(60 50% 62.5% / 0.25)", "rgba(207, 207, 112, 0.25)", +"hsl(90 50% 62.5% / 0.25)", "rgba(159, 207, 112, 0.25)", +"hsl(120 50% 62.5% / 0.25)", "rgba(112, 207, 112, 0.25)", +"hsl(150 50% 62.5% / 0.25)", "rgba(112, 207, 159, 0.25)", +"hsl(180 50% 62.5% / 0.25)", "rgba(112, 207, 207, 0.25)", +"hsl(210 50% 62.5% / 0.25)", "rgba(112, 159, 207, 0.25)", +"hsl(240 50% 62.5% / 0.25)", "rgba(112, 112, 207, 0.25)", +"hsl(270 50% 62.5% / 0.25)", "rgba(159, 112, 207, 0.25)", +"hsl(300 50% 62.5% / 0.25)", "rgba(207, 112, 207, 0.25)", +"hsl(330 50% 62.5% / 0.25)", "rgba(207, 112, 159, 0.25)", +"hsl(0 62.5% 62.5% / 0.25)", "rgba(219, 100, 100, 0.25)", +"hsl(30 62.5% 62.5% / 0.25)", "rgba(219, 159, 100, 0.25)", +"hsl(60 62.5% 62.5% / 0.25)", "rgba(219, 219, 100, 0.25)", +"hsl(90 62.5% 62.5% / 0.25)", "rgba(159, 219, 100, 0.25)", +"hsl(120 62.5% 62.5% / 0.25)", "rgba(100, 219, 100, 0.25)", +"hsl(150 62.5% 62.5% / 0.25)", "rgba(100, 219, 159, 0.25)", +"hsl(180 62.5% 62.5% / 0.25)", "rgba(100, 219, 219, 0.25)", +"hsl(210 62.5% 62.5% / 0.25)", "rgba(100, 159, 219, 0.25)", +"hsl(240 62.5% 62.5% / 0.25)", "rgba(100, 100, 219, 0.25)", +"hsl(270 62.5% 62.5% / 0.25)", "rgba(159, 100, 219, 0.25)", +"hsl(300 62.5% 62.5% / 0.25)", "rgba(219, 100, 219, 0.25)", +"hsl(330 62.5% 62.5% / 0.25)", "rgba(219, 100, 159, 0.25)", +"hsl(0 75% 62.5% / 0.25)", "rgba(231, 88, 88, 0.25)", +"hsl(30 75% 62.5% / 0.25)", "rgba(231, 159, 88, 0.25)", +"hsl(60 75% 62.5% / 0.25)", "rgba(231, 231, 88, 0.25)", +"hsl(90 75% 62.5% / 0.25)", "rgba(159, 231, 88, 0.25)", +"hsl(120 75% 62.5% / 0.25)", "rgba(88, 231, 88, 0.25)", +"hsl(150 75% 62.5% / 0.25)", "rgba(88, 231, 159, 0.25)", +"hsl(180 75% 62.5% / 0.25)", "rgba(88, 231, 231, 0.25)", +"hsl(210 75% 62.5% / 0.25)", "rgba(88, 159, 231, 0.25)", +"hsl(240 75% 62.5% / 0.25)", "rgba(88, 88, 231, 0.25)", +"hsl(270 75% 62.5% / 0.25)", "rgba(159, 88, 231, 0.25)", +"hsl(300 75% 62.5% / 0.25)", "rgba(231, 88, 231, 0.25)", +"hsl(330 75% 62.5% / 0.25)", "rgba(231, 88, 159, 0.25)", +"hsl(0 87.5% 62.5% / 0.25)", "rgba(243, 76, 76, 0.25)", +"hsl(30 87.5% 62.5% / 0.25)", "rgba(243, 159, 76, 0.25)", +"hsl(60 87.5% 62.5% / 0.25)", "rgba(243, 243, 76, 0.25)", +"hsl(90 87.5% 62.5% / 0.25)", "rgba(159, 243, 76, 0.25)", +"hsl(120 87.5% 62.5% / 0.25)", "rgba(76, 243, 76, 0.25)", +"hsl(150 87.5% 62.5% / 0.25)", "rgba(76, 243, 159, 0.25)", +"hsl(180 87.5% 62.5% / 0.25)", "rgba(76, 243, 243, 0.25)", +"hsl(210 87.5% 62.5% / 0.25)", "rgba(76, 159, 243, 0.25)", +"hsl(240 87.5% 62.5% / 0.25)", "rgba(76, 76, 243, 0.25)", +"hsl(270 87.5% 62.5% / 0.25)", "rgba(159, 76, 243, 0.25)", +"hsl(300 87.5% 62.5% / 0.25)", "rgba(243, 76, 243, 0.25)", +"hsl(330 87.5% 62.5% / 0.25)", "rgba(243, 76, 159, 0.25)", +"hsl(0 100% 62.5% / 0.25)", "rgba(255, 64, 64, 0.25)", +"hsl(30 100% 62.5% / 0.25)", "rgba(255, 159, 64, 0.25)", +"hsl(60 100% 62.5% / 0.25)", "rgba(255, 255, 64, 0.25)", +"hsl(90 100% 62.5% / 0.25)", "rgba(159, 255, 64, 0.25)", +"hsl(120 100% 62.5% / 0.25)", "rgba(64, 255, 64, 0.25)", +"hsl(150 100% 62.5% / 0.25)", "rgba(64, 255, 159, 0.25)", +"hsl(180 100% 62.5% / 0.25)", "rgba(64, 255, 255, 0.25)", +"hsl(210 100% 62.5% / 0.25)", "rgba(64, 159, 255, 0.25)", +"hsl(240 100% 62.5% / 0.25)", "rgba(64, 64, 255, 0.25)", +"hsl(270 100% 62.5% / 0.25)", "rgba(159, 64, 255, 0.25)", +"hsl(300 100% 62.5% / 0.25)", "rgba(255, 64, 255, 0.25)", +"hsl(330 100% 62.5% / 0.25)", "rgba(255, 64, 159, 0.25)", +"hsl(0 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(30 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(60 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(90 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(120 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(150 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(180 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(210 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(240 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(270 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(300 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(330 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsl(0 12.5% 75% / 0.25)", "rgba(199, 183, 183, 0.25)", +"hsl(30 12.5% 75% / 0.25)", "rgba(199, 191, 183, 0.25)", +"hsl(60 12.5% 75% / 0.25)", "rgba(199, 199, 183, 0.25)", +"hsl(90 12.5% 75% / 0.25)", "rgba(191, 199, 183, 0.25)", +"hsl(120 12.5% 75% / 0.25)", "rgba(183, 199, 183, 0.25)", +"hsl(150 12.5% 75% / 0.25)", "rgba(183, 199, 191, 0.25)", +"hsl(180 12.5% 75% / 0.25)", "rgba(183, 199, 199, 0.25)", +"hsl(210 12.5% 75% / 0.25)", "rgba(183, 191, 199, 0.25)", +"hsl(240 12.5% 75% / 0.25)", "rgba(183, 183, 199, 0.25)", +"hsl(270 12.5% 75% / 0.25)", "rgba(191, 183, 199, 0.25)", +"hsl(300 12.5% 75% / 0.25)", "rgba(199, 183, 199, 0.25)", +"hsl(330 12.5% 75% / 0.25)", "rgba(199, 183, 191, 0.25)", +"hsl(0 25% 75% / 0.25)", "rgba(207, 175, 175, 0.25)", +"hsl(30 25% 75% / 0.25)", "rgba(207, 191, 175, 0.25)", +"hsl(60 25% 75% / 0.25)", "rgba(207, 207, 175, 0.25)", +"hsl(90 25% 75% / 0.25)", "rgba(191, 207, 175, 0.25)", +"hsl(120 25% 75% / 0.25)", "rgba(175, 207, 175, 0.25)", +"hsl(150 25% 75% / 0.25)", "rgba(175, 207, 191, 0.25)", +"hsl(180 25% 75% / 0.25)", "rgba(175, 207, 207, 0.25)", +"hsl(210 25% 75% / 0.25)", "rgba(175, 191, 207, 0.25)", +"hsl(240 25% 75% / 0.25)", "rgba(175, 175, 207, 0.25)", +"hsl(270 25% 75% / 0.25)", "rgba(191, 175, 207, 0.25)", +"hsl(300 25% 75% / 0.25)", "rgba(207, 175, 207, 0.25)", +"hsl(330 25% 75% / 0.25)", "rgba(207, 175, 191, 0.25)", +"hsl(0 37.5% 75% / 0.25)", "rgba(215, 167, 167, 0.25)", +"hsl(30 37.5% 75% / 0.25)", "rgba(215, 191, 167, 0.25)", +"hsl(60 37.5% 75% / 0.25)", "rgba(215, 215, 167, 0.25)", +"hsl(90 37.5% 75% / 0.25)", "rgba(191, 215, 167, 0.25)", +"hsl(120 37.5% 75% / 0.25)", "rgba(167, 215, 167, 0.25)", +"hsl(150 37.5% 75% / 0.25)", "rgba(167, 215, 191, 0.25)", +"hsl(180 37.5% 75% / 0.25)", "rgba(167, 215, 215, 0.25)", +"hsl(210 37.5% 75% / 0.25)", "rgba(167, 191, 215, 0.25)", +"hsl(240 37.5% 75% / 0.25)", "rgba(167, 167, 215, 0.25)", +"hsl(270 37.5% 75% / 0.25)", "rgba(191, 167, 215, 0.25)", +"hsl(300 37.5% 75% / 0.25)", "rgba(215, 167, 215, 0.25)", +"hsl(330 37.5% 75% / 0.25)", "rgba(215, 167, 191, 0.25)", +"hsl(0 50% 75% / 0.25)", "rgba(223, 159, 159, 0.25)", +"hsl(30 50% 75% / 0.25)", "rgba(223, 191, 159, 0.25)", +"hsl(60 50% 75% / 0.25)", "rgba(223, 223, 159, 0.25)", +"hsl(90 50% 75% / 0.25)", "rgba(191, 223, 159, 0.25)", +"hsl(120 50% 75% / 0.25)", "rgba(159, 223, 159, 0.25)", +"hsl(150 50% 75% / 0.25)", "rgba(159, 223, 191, 0.25)", +"hsl(180 50% 75% / 0.25)", "rgba(159, 223, 223, 0.25)", +"hsl(210 50% 75% / 0.25)", "rgba(159, 191, 223, 0.25)", +"hsl(240 50% 75% / 0.25)", "rgba(159, 159, 223, 0.25)", +"hsl(270 50% 75% / 0.25)", "rgba(191, 159, 223, 0.25)", +"hsl(300 50% 75% / 0.25)", "rgba(223, 159, 223, 0.25)", +"hsl(330 50% 75% / 0.25)", "rgba(223, 159, 191, 0.25)", +"hsl(0 62.5% 75% / 0.25)", "rgba(231, 151, 151, 0.25)", +"hsl(30 62.5% 75% / 0.25)", "rgba(231, 191, 151, 0.25)", +"hsl(60 62.5% 75% / 0.25)", "rgba(231, 231, 151, 0.25)", +"hsl(90 62.5% 75% / 0.25)", "rgba(191, 231, 151, 0.25)", +"hsl(120 62.5% 75% / 0.25)", "rgba(151, 231, 151, 0.25)", +"hsl(150 62.5% 75% / 0.25)", "rgba(151, 231, 191, 0.25)", +"hsl(180 62.5% 75% / 0.25)", "rgba(151, 231, 231, 0.25)", +"hsl(210 62.5% 75% / 0.25)", "rgba(151, 191, 231, 0.25)", +"hsl(240 62.5% 75% / 0.25)", "rgba(151, 151, 231, 0.25)", +"hsl(270 62.5% 75% / 0.25)", "rgba(191, 151, 231, 0.25)", +"hsl(300 62.5% 75% / 0.25)", "rgba(231, 151, 231, 0.25)", +"hsl(330 62.5% 75% / 0.25)", "rgba(231, 151, 191, 0.25)", +"hsl(0 75% 75% / 0.25)", "rgba(239, 143, 143, 0.25)", +"hsl(30 75% 75% / 0.25)", "rgba(239, 191, 143, 0.25)", +"hsl(60 75% 75% / 0.25)", "rgba(239, 239, 143, 0.25)", +"hsl(90 75% 75% / 0.25)", "rgba(191, 239, 143, 0.25)", +"hsl(120 75% 75% / 0.25)", "rgba(143, 239, 143, 0.25)", +"hsl(150 75% 75% / 0.25)", "rgba(143, 239, 191, 0.25)", +"hsl(180 75% 75% / 0.25)", "rgba(143, 239, 239, 0.25)", +"hsl(210 75% 75% / 0.25)", "rgba(143, 191, 239, 0.25)", +"hsl(240 75% 75% / 0.25)", "rgba(143, 143, 239, 0.25)", +"hsl(270 75% 75% / 0.25)", "rgba(191, 143, 239, 0.25)", +"hsl(300 75% 75% / 0.25)", "rgba(239, 143, 239, 0.25)", +"hsl(330 75% 75% / 0.25)", "rgba(239, 143, 191, 0.25)", +"hsl(0 87.5% 75% / 0.25)", "rgba(247, 135, 135, 0.25)", +"hsl(30 87.5% 75% / 0.25)", "rgba(247, 191, 135, 0.25)", +"hsl(60 87.5% 75% / 0.25)", "rgba(247, 247, 135, 0.25)", +"hsl(90 87.5% 75% / 0.25)", "rgba(191, 247, 135, 0.25)", +"hsl(120 87.5% 75% / 0.25)", "rgba(135, 247, 135, 0.25)", +"hsl(150 87.5% 75% / 0.25)", "rgba(135, 247, 191, 0.25)", +"hsl(180 87.5% 75% / 0.25)", "rgba(135, 247, 247, 0.25)", +"hsl(210 87.5% 75% / 0.25)", "rgba(135, 191, 247, 0.25)", +"hsl(240 87.5% 75% / 0.25)", "rgba(135, 135, 247, 0.25)", +"hsl(270 87.5% 75% / 0.25)", "rgba(191, 135, 247, 0.25)", +"hsl(300 87.5% 75% / 0.25)", "rgba(247, 135, 247, 0.25)", +"hsl(330 87.5% 75% / 0.25)", "rgba(247, 135, 191, 0.25)", +"hsl(0 100% 75% / 0.25)", "rgba(255, 128, 128, 0.25)", +"hsl(30 100% 75% / 0.25)", "rgba(255, 191, 128, 0.25)", +"hsl(60 100% 75% / 0.25)", "rgba(255, 255, 128, 0.25)", +"hsl(90 100% 75% / 0.25)", "rgba(191, 255, 128, 0.25)", +"hsl(120 100% 75% / 0.25)", "rgba(128, 255, 128, 0.25)", +"hsl(150 100% 75% / 0.25)", "rgba(128, 255, 191, 0.25)", +"hsl(180 100% 75% / 0.25)", "rgba(128, 255, 255, 0.25)", +"hsl(210 100% 75% / 0.25)", "rgba(128, 191, 255, 0.25)", +"hsl(240 100% 75% / 0.25)", "rgba(128, 128, 255, 0.25)", +"hsl(270 100% 75% / 0.25)", "rgba(191, 128, 255, 0.25)", +"hsl(300 100% 75% / 0.25)", "rgba(255, 128, 255, 0.25)", +"hsl(330 100% 75% / 0.25)", "rgba(255, 128, 191, 0.25)", +"hsl(0 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(30 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(60 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(90 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(120 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(150 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(180 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(210 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(240 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(270 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(300 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(330 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsl(0 12.5% 87.5% / 0.25)", "rgba(227, 219, 219, 0.25)", +"hsl(30 12.5% 87.5% / 0.25)", "rgba(227, 223, 219, 0.25)", +"hsl(60 12.5% 87.5% / 0.25)", "rgba(227, 227, 219, 0.25)", +"hsl(90 12.5% 87.5% / 0.25)", "rgba(223, 227, 219, 0.25)", +"hsl(120 12.5% 87.5% / 0.25)", "rgba(219, 227, 219, 0.25)", +"hsl(150 12.5% 87.5% / 0.25)", "rgba(219, 227, 223, 0.25)", +"hsl(180 12.5% 87.5% / 0.25)", "rgba(219, 227, 227, 0.25)", +"hsl(210 12.5% 87.5% / 0.25)", "rgba(219, 223, 227, 0.25)", +"hsl(240 12.5% 87.5% / 0.25)", "rgba(219, 219, 227, 0.25)", +"hsl(270 12.5% 87.5% / 0.25)", "rgba(223, 219, 227, 0.25)", +"hsl(300 12.5% 87.5% / 0.25)", "rgba(227, 219, 227, 0.25)", +"hsl(330 12.5% 87.5% / 0.25)", "rgba(227, 219, 223, 0.25)", +"hsl(0 25% 87.5% / 0.25)", "rgba(231, 215, 215, 0.25)", +"hsl(30 25% 87.5% / 0.25)", "rgba(231, 223, 215, 0.25)", +"hsl(60 25% 87.5% / 0.25)", "rgba(231, 231, 215, 0.25)", +"hsl(90 25% 87.5% / 0.25)", "rgba(223, 231, 215, 0.25)", +"hsl(120 25% 87.5% / 0.25)", "rgba(215, 231, 215, 0.25)", +"hsl(150 25% 87.5% / 0.25)", "rgba(215, 231, 223, 0.25)", +"hsl(180 25% 87.5% / 0.25)", "rgba(215, 231, 231, 0.25)", +"hsl(210 25% 87.5% / 0.25)", "rgba(215, 223, 231, 0.25)", +"hsl(240 25% 87.5% / 0.25)", "rgba(215, 215, 231, 0.25)", +"hsl(270 25% 87.5% / 0.25)", "rgba(223, 215, 231, 0.25)", +"hsl(300 25% 87.5% / 0.25)", "rgba(231, 215, 231, 0.25)", +"hsl(330 25% 87.5% / 0.25)", "rgba(231, 215, 223, 0.25)", +"hsl(0 37.5% 87.5% / 0.25)", "rgba(235, 211, 211, 0.25)", +"hsl(30 37.5% 87.5% / 0.25)", "rgba(235, 223, 211, 0.25)", +"hsl(60 37.5% 87.5% / 0.25)", "rgba(235, 235, 211, 0.25)", +"hsl(90 37.5% 87.5% / 0.25)", "rgba(223, 235, 211, 0.25)", +"hsl(120 37.5% 87.5% / 0.25)", "rgba(211, 235, 211, 0.25)", +"hsl(150 37.5% 87.5% / 0.25)", "rgba(211, 235, 223, 0.25)", +"hsl(180 37.5% 87.5% / 0.25)", "rgba(211, 235, 235, 0.25)", +"hsl(210 37.5% 87.5% / 0.25)", "rgba(211, 223, 235, 0.25)", +"hsl(240 37.5% 87.5% / 0.25)", "rgba(211, 211, 235, 0.25)", +"hsl(270 37.5% 87.5% / 0.25)", "rgba(223, 211, 235, 0.25)", +"hsl(300 37.5% 87.5% / 0.25)", "rgba(235, 211, 235, 0.25)", +"hsl(330 37.5% 87.5% / 0.25)", "rgba(235, 211, 223, 0.25)", +"hsl(0 50% 87.5% / 0.25)", "rgba(239, 207, 207, 0.25)", +"hsl(30 50% 87.5% / 0.25)", "rgba(239, 223, 207, 0.25)", +"hsl(60 50% 87.5% / 0.25)", "rgba(239, 239, 207, 0.25)", +"hsl(90 50% 87.5% / 0.25)", "rgba(223, 239, 207, 0.25)", +"hsl(120 50% 87.5% / 0.25)", "rgba(207, 239, 207, 0.25)", +"hsl(150 50% 87.5% / 0.25)", "rgba(207, 239, 223, 0.25)", +"hsl(180 50% 87.5% / 0.25)", "rgba(207, 239, 239, 0.25)", +"hsl(210 50% 87.5% / 0.25)", "rgba(207, 223, 239, 0.25)", +"hsl(240 50% 87.5% / 0.25)", "rgba(207, 207, 239, 0.25)", +"hsl(270 50% 87.5% / 0.25)", "rgba(223, 207, 239, 0.25)", +"hsl(300 50% 87.5% / 0.25)", "rgba(239, 207, 239, 0.25)", +"hsl(330 50% 87.5% / 0.25)", "rgba(239, 207, 223, 0.25)", +"hsl(0 62.5% 87.5% / 0.25)", "rgba(243, 203, 203, 0.25)", +"hsl(30 62.5% 87.5% / 0.25)", "rgba(243, 223, 203, 0.25)", +"hsl(60 62.5% 87.5% / 0.25)", "rgba(243, 243, 203, 0.25)", +"hsl(90 62.5% 87.5% / 0.25)", "rgba(223, 243, 203, 0.25)", +"hsl(120 62.5% 87.5% / 0.25)", "rgba(203, 243, 203, 0.25)", +"hsl(150 62.5% 87.5% / 0.25)", "rgba(203, 243, 223, 0.25)", +"hsl(180 62.5% 87.5% / 0.25)", "rgba(203, 243, 243, 0.25)", +"hsl(210 62.5% 87.5% / 0.25)", "rgba(203, 223, 243, 0.25)", +"hsl(240 62.5% 87.5% / 0.25)", "rgba(203, 203, 243, 0.25)", +"hsl(270 62.5% 87.5% / 0.25)", "rgba(223, 203, 243, 0.25)", +"hsl(300 62.5% 87.5% / 0.25)", "rgba(243, 203, 243, 0.25)", +"hsl(330 62.5% 87.5% / 0.25)", "rgba(243, 203, 223, 0.25)", +"hsl(0 75% 87.5% / 0.25)", "rgba(247, 199, 199, 0.25)", +"hsl(30 75% 87.5% / 0.25)", "rgba(247, 223, 199, 0.25)", +"hsl(60 75% 87.5% / 0.25)", "rgba(247, 247, 199, 0.25)", +"hsl(90 75% 87.5% / 0.25)", "rgba(223, 247, 199, 0.25)", +"hsl(120 75% 87.5% / 0.25)", "rgba(199, 247, 199, 0.25)", +"hsl(150 75% 87.5% / 0.25)", "rgba(199, 247, 223, 0.25)", +"hsl(180 75% 87.5% / 0.25)", "rgba(199, 247, 247, 0.25)", +"hsl(210 75% 87.5% / 0.25)", "rgba(199, 223, 247, 0.25)", +"hsl(240 75% 87.5% / 0.25)", "rgba(199, 199, 247, 0.25)", +"hsl(270 75% 87.5% / 0.25)", "rgba(223, 199, 247, 0.25)", +"hsl(300 75% 87.5% / 0.25)", "rgba(247, 199, 247, 0.25)", +"hsl(330 75% 87.5% / 0.25)", "rgba(247, 199, 223, 0.25)", +"hsl(0 87.5% 87.5% / 0.25)", "rgba(251, 195, 195, 0.25)", +"hsl(30 87.5% 87.5% / 0.25)", "rgba(251, 223, 195, 0.25)", +"hsl(60 87.5% 87.5% / 0.25)", "rgba(251, 251, 195, 0.25)", +"hsl(90 87.5% 87.5% / 0.25)", "rgba(223, 251, 195, 0.25)", +"hsl(120 87.5% 87.5% / 0.25)", "rgba(195, 251, 195, 0.25)", +"hsl(150 87.5% 87.5% / 0.25)", "rgba(195, 251, 223, 0.25)", +"hsl(180 87.5% 87.5% / 0.25)", "rgba(195, 251, 251, 0.25)", +"hsl(210 87.5% 87.5% / 0.25)", "rgba(195, 223, 251, 0.25)", +"hsl(240 87.5% 87.5% / 0.25)", "rgba(195, 195, 251, 0.25)", +"hsl(270 87.5% 87.5% / 0.25)", "rgba(223, 195, 251, 0.25)", +"hsl(300 87.5% 87.5% / 0.25)", "rgba(251, 195, 251, 0.25)", +"hsl(330 87.5% 87.5% / 0.25)", "rgba(251, 195, 223, 0.25)", +"hsl(0 100% 87.5% / 0.25)", "rgba(255, 191, 191, 0.25)", +"hsl(30 100% 87.5% / 0.25)", "rgba(255, 223, 191, 0.25)", +"hsl(60 100% 87.5% / 0.25)", "rgba(255, 255, 191, 0.25)", +"hsl(90 100% 87.5% / 0.25)", "rgba(223, 255, 191, 0.25)", +"hsl(120 100% 87.5% / 0.25)", "rgba(191, 255, 191, 0.25)", +"hsl(150 100% 87.5% / 0.25)", "rgba(191, 255, 223, 0.25)", +"hsl(180 100% 87.5% / 0.25)", "rgba(191, 255, 255, 0.25)", +"hsl(210 100% 87.5% / 0.25)", "rgba(191, 223, 255, 0.25)", +"hsl(240 100% 87.5% / 0.25)", "rgba(191, 191, 255, 0.25)", +"hsl(270 100% 87.5% / 0.25)", "rgba(223, 191, 255, 0.25)", +"hsl(300 100% 87.5% / 0.25)", "rgba(255, 191, 255, 0.25)", +"hsl(330 100% 87.5% / 0.25)", "rgba(255, 191, 223, 0.25)", +"hsl(0 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(30 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(60 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(90 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(120 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(150 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(180 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(210 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(240 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(270 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(300 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(330 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsl(0 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(30 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(60 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(90 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(120 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(150 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(180 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(210 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(240 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(270 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(300 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(330 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsl(0 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(30 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(60 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(90 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(120 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(150 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(180 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(210 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(240 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(270 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(300 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(330 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsl(0 12.5% 12.5% / 0.0)", "rgba(36, 28, 28, 0)", +"hsl(30 12.5% 12.5% / 0.0)", "rgba(36, 32, 28, 0)", +"hsl(60 12.5% 12.5% / 0.0)", "rgba(36, 36, 28, 0)", +"hsl(90 12.5% 12.5% / 0.0)", "rgba(32, 36, 28, 0)", +"hsl(120 12.5% 12.5% / 0.0)", "rgba(28, 36, 28, 0)", +"hsl(150 12.5% 12.5% / 0.0)", "rgba(28, 36, 32, 0)", +"hsl(180 12.5% 12.5% / 0.0)", "rgba(28, 36, 36, 0)", +"hsl(210 12.5% 12.5% / 0.0)", "rgba(28, 32, 36, 0)", +"hsl(240 12.5% 12.5% / 0.0)", "rgba(28, 28, 36, 0)", +"hsl(270 12.5% 12.5% / 0.0)", "rgba(32, 28, 36, 0)", +"hsl(300 12.5% 12.5% / 0.0)", "rgba(36, 28, 36, 0)", +"hsl(330 12.5% 12.5% / 0.0)", "rgba(36, 28, 32, 0)", +"hsl(0 25% 12.5% / 0.0)", "rgba(40, 24, 24, 0)", +"hsl(30 25% 12.5% / 0.0)", "rgba(40, 32, 24, 0)", +"hsl(60 25% 12.5% / 0.0)", "rgba(40, 40, 24, 0)", +"hsl(90 25% 12.5% / 0.0)", "rgba(32, 40, 24, 0)", +"hsl(120 25% 12.5% / 0.0)", "rgba(24, 40, 24, 0)", +"hsl(150 25% 12.5% / 0.0)", "rgba(24, 40, 32, 0)", +"hsl(180 25% 12.5% / 0.0)", "rgba(24, 40, 40, 0)", +"hsl(210 25% 12.5% / 0.0)", "rgba(24, 32, 40, 0)", +"hsl(240 25% 12.5% / 0.0)", "rgba(24, 24, 40, 0)", +"hsl(270 25% 12.5% / 0.0)", "rgba(32, 24, 40, 0)", +"hsl(300 25% 12.5% / 0.0)", "rgba(40, 24, 40, 0)", +"hsl(330 25% 12.5% / 0.0)", "rgba(40, 24, 32, 0)", +"hsl(0 37.5% 12.5% / 0.0)", "rgba(44, 20, 20, 0)", +"hsl(30 37.5% 12.5% / 0.0)", "rgba(44, 32, 20, 0)", +"hsl(60 37.5% 12.5% / 0.0)", "rgba(44, 44, 20, 0)", +"hsl(90 37.5% 12.5% / 0.0)", "rgba(32, 44, 20, 0)", +"hsl(120 37.5% 12.5% / 0.0)", "rgba(20, 44, 20, 0)", +"hsl(150 37.5% 12.5% / 0.0)", "rgba(20, 44, 32, 0)", +"hsl(180 37.5% 12.5% / 0.0)", "rgba(20, 44, 44, 0)", +"hsl(210 37.5% 12.5% / 0.0)", "rgba(20, 32, 44, 0)", +"hsl(240 37.5% 12.5% / 0.0)", "rgba(20, 20, 44, 0)", +"hsl(270 37.5% 12.5% / 0.0)", "rgba(32, 20, 44, 0)", +"hsl(300 37.5% 12.5% / 0.0)", "rgba(44, 20, 44, 0)", +"hsl(330 37.5% 12.5% / 0.0)", "rgba(44, 20, 32, 0)", +"hsl(0 50% 12.5% / 0.0)", "rgba(48, 16, 16, 0)", +"hsl(30 50% 12.5% / 0.0)", "rgba(48, 32, 16, 0)", +"hsl(60 50% 12.5% / 0.0)", "rgba(48, 48, 16, 0)", +"hsl(90 50% 12.5% / 0.0)", "rgba(32, 48, 16, 0)", +"hsl(120 50% 12.5% / 0.0)", "rgba(16, 48, 16, 0)", +"hsl(150 50% 12.5% / 0.0)", "rgba(16, 48, 32, 0)", +"hsl(180 50% 12.5% / 0.0)", "rgba(16, 48, 48, 0)", +"hsl(210 50% 12.5% / 0.0)", "rgba(16, 32, 48, 0)", +"hsl(240 50% 12.5% / 0.0)", "rgba(16, 16, 48, 0)", +"hsl(270 50% 12.5% / 0.0)", "rgba(32, 16, 48, 0)", +"hsl(300 50% 12.5% / 0.0)", "rgba(48, 16, 48, 0)", +"hsl(330 50% 12.5% / 0.0)", "rgba(48, 16, 32, 0)", +"hsl(0 62.5% 12.5% / 0.0)", "rgba(52, 12, 12, 0)", +"hsl(30 62.5% 12.5% / 0.0)", "rgba(52, 32, 12, 0)", +"hsl(60 62.5% 12.5% / 0.0)", "rgba(52, 52, 12, 0)", +"hsl(90 62.5% 12.5% / 0.0)", "rgba(32, 52, 12, 0)", +"hsl(120 62.5% 12.5% / 0.0)", "rgba(12, 52, 12, 0)", +"hsl(150 62.5% 12.5% / 0.0)", "rgba(12, 52, 32, 0)", +"hsl(180 62.5% 12.5% / 0.0)", "rgba(12, 52, 52, 0)", +"hsl(210 62.5% 12.5% / 0.0)", "rgba(12, 32, 52, 0)", +"hsl(240 62.5% 12.5% / 0.0)", "rgba(12, 12, 52, 0)", +"hsl(270 62.5% 12.5% / 0.0)", "rgba(32, 12, 52, 0)", +"hsl(300 62.5% 12.5% / 0.0)", "rgba(52, 12, 52, 0)", +"hsl(330 62.5% 12.5% / 0.0)", "rgba(52, 12, 32, 0)", +"hsl(0 75% 12.5% / 0.0)", "rgba(56, 8, 8, 0)", +"hsl(30 75% 12.5% / 0.0)", "rgba(56, 32, 8, 0)", +"hsl(60 75% 12.5% / 0.0)", "rgba(56, 56, 8, 0)", +"hsl(90 75% 12.5% / 0.0)", "rgba(32, 56, 8, 0)", +"hsl(120 75% 12.5% / 0.0)", "rgba(8, 56, 8, 0)", +"hsl(150 75% 12.5% / 0.0)", "rgba(8, 56, 32, 0)", +"hsl(180 75% 12.5% / 0.0)", "rgba(8, 56, 56, 0)", +"hsl(210 75% 12.5% / 0.0)", "rgba(8, 32, 56, 0)", +"hsl(240 75% 12.5% / 0.0)", "rgba(8, 8, 56, 0)", +"hsl(270 75% 12.5% / 0.0)", "rgba(32, 8, 56, 0)", +"hsl(300 75% 12.5% / 0.0)", "rgba(56, 8, 56, 0)", +"hsl(330 75% 12.5% / 0.0)", "rgba(56, 8, 32, 0)", +"hsl(0 87.5% 12.5% / 0.0)", "rgba(60, 4, 4, 0)", +"hsl(30 87.5% 12.5% / 0.0)", "rgba(60, 32, 4, 0)", +"hsl(60 87.5% 12.5% / 0.0)", "rgba(60, 60, 4, 0)", +"hsl(90 87.5% 12.5% / 0.0)", "rgba(32, 60, 4, 0)", +"hsl(120 87.5% 12.5% / 0.0)", "rgba(4, 60, 4, 0)", +"hsl(150 87.5% 12.5% / 0.0)", "rgba(4, 60, 32, 0)", +"hsl(180 87.5% 12.5% / 0.0)", "rgba(4, 60, 60, 0)", +"hsl(210 87.5% 12.5% / 0.0)", "rgba(4, 32, 60, 0)", +"hsl(240 87.5% 12.5% / 0.0)", "rgba(4, 4, 60, 0)", +"hsl(270 87.5% 12.5% / 0.0)", "rgba(32, 4, 60, 0)", +"hsl(300 87.5% 12.5% / 0.0)", "rgba(60, 4, 60, 0)", +"hsl(330 87.5% 12.5% / 0.0)", "rgba(60, 4, 32, 0)", +"hsl(0 100% 12.5% / 0.0)", "rgba(64, 0, 0, 0)", +"hsl(30 100% 12.5% / 0.0)", "rgba(64, 32, 0, 0)", +"hsl(60 100% 12.5% / 0.0)", "rgba(64, 64, 0, 0)", +"hsl(90 100% 12.5% / 0.0)", "rgba(32, 64, 0, 0)", +"hsl(120 100% 12.5% / 0.0)", "rgba(0, 64, 0, 0)", +"hsl(150 100% 12.5% / 0.0)", "rgba(0, 64, 32, 0)", +"hsl(180 100% 12.5% / 0.0)", "rgba(0, 64, 64, 0)", +"hsl(210 100% 12.5% / 0.0)", "rgba(0, 32, 64, 0)", +"hsl(240 100% 12.5% / 0.0)", "rgba(0, 0, 64, 0)", +"hsl(270 100% 12.5% / 0.0)", "rgba(32, 0, 64, 0)", +"hsl(300 100% 12.5% / 0.0)", "rgba(64, 0, 64, 0)", +"hsl(330 100% 12.5% / 0.0)", "rgba(64, 0, 32, 0)", +"hsl(0 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(30 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(60 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(90 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(120 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(150 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(180 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(210 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(240 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(270 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(300 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(330 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsl(0 12.5% 25% / 0.0)", "rgba(72, 56, 56, 0)", +"hsl(30 12.5% 25% / 0.0)", "rgba(72, 64, 56, 0)", +"hsl(60 12.5% 25% / 0.0)", "rgba(72, 72, 56, 0)", +"hsl(90 12.5% 25% / 0.0)", "rgba(64, 72, 56, 0)", +"hsl(120 12.5% 25% / 0.0)", "rgba(56, 72, 56, 0)", +"hsl(150 12.5% 25% / 0.0)", "rgba(56, 72, 64, 0)", +"hsl(180 12.5% 25% / 0.0)", "rgba(56, 72, 72, 0)", +"hsl(210 12.5% 25% / 0.0)", "rgba(56, 64, 72, 0)", +"hsl(240 12.5% 25% / 0.0)", "rgba(56, 56, 72, 0)", +"hsl(270 12.5% 25% / 0.0)", "rgba(64, 56, 72, 0)", +"hsl(300 12.5% 25% / 0.0)", "rgba(72, 56, 72, 0)", +"hsl(330 12.5% 25% / 0.0)", "rgba(72, 56, 64, 0)", +"hsl(0 25% 25% / 0.0)", "rgba(80, 48, 48, 0)", +"hsl(30 25% 25% / 0.0)", "rgba(80, 64, 48, 0)", +"hsl(60 25% 25% / 0.0)", "rgba(80, 80, 48, 0)", +"hsl(90 25% 25% / 0.0)", "rgba(64, 80, 48, 0)", +"hsl(120 25% 25% / 0.0)", "rgba(48, 80, 48, 0)", +"hsl(150 25% 25% / 0.0)", "rgba(48, 80, 64, 0)", +"hsl(180 25% 25% / 0.0)", "rgba(48, 80, 80, 0)", +"hsl(210 25% 25% / 0.0)", "rgba(48, 64, 80, 0)", +"hsl(240 25% 25% / 0.0)", "rgba(48, 48, 80, 0)", +"hsl(270 25% 25% / 0.0)", "rgba(64, 48, 80, 0)", +"hsl(300 25% 25% / 0.0)", "rgba(80, 48, 80, 0)", +"hsl(330 25% 25% / 0.0)", "rgba(80, 48, 64, 0)", +"hsl(0 37.5% 25% / 0.0)", "rgba(88, 40, 40, 0)", +"hsl(30 37.5% 25% / 0.0)", "rgba(88, 64, 40, 0)", +"hsl(60 37.5% 25% / 0.0)", "rgba(88, 88, 40, 0)", +"hsl(90 37.5% 25% / 0.0)", "rgba(64, 88, 40, 0)", +"hsl(120 37.5% 25% / 0.0)", "rgba(40, 88, 40, 0)", +"hsl(150 37.5% 25% / 0.0)", "rgba(40, 88, 64, 0)", +"hsl(180 37.5% 25% / 0.0)", "rgba(40, 88, 88, 0)", +"hsl(210 37.5% 25% / 0.0)", "rgba(40, 64, 88, 0)", +"hsl(240 37.5% 25% / 0.0)", "rgba(40, 40, 88, 0)", +"hsl(270 37.5% 25% / 0.0)", "rgba(64, 40, 88, 0)", +"hsl(300 37.5% 25% / 0.0)", "rgba(88, 40, 88, 0)", +"hsl(330 37.5% 25% / 0.0)", "rgba(88, 40, 64, 0)", +"hsl(0 50% 25% / 0.0)", "rgba(96, 32, 32, 0)", +"hsl(30 50% 25% / 0.0)", "rgba(96, 64, 32, 0)", +"hsl(60 50% 25% / 0.0)", "rgba(96, 96, 32, 0)", +"hsl(90 50% 25% / 0.0)", "rgba(64, 96, 32, 0)", +"hsl(120 50% 25% / 0.0)", "rgba(32, 96, 32, 0)", +"hsl(150 50% 25% / 0.0)", "rgba(32, 96, 64, 0)", +"hsl(180 50% 25% / 0.0)", "rgba(32, 96, 96, 0)", +"hsl(210 50% 25% / 0.0)", "rgba(32, 64, 96, 0)", +"hsl(240 50% 25% / 0.0)", "rgba(32, 32, 96, 0)", +"hsl(270 50% 25% / 0.0)", "rgba(64, 32, 96, 0)", +"hsl(300 50% 25% / 0.0)", "rgba(96, 32, 96, 0)", +"hsl(330 50% 25% / 0.0)", "rgba(96, 32, 64, 0)", +"hsl(0 62.5% 25% / 0.0)", "rgba(104, 24, 24, 0)", +"hsl(30 62.5% 25% / 0.0)", "rgba(104, 64, 24, 0)", +"hsl(60 62.5% 25% / 0.0)", "rgba(104, 104, 24, 0)", +"hsl(90 62.5% 25% / 0.0)", "rgba(64, 104, 24, 0)", +"hsl(120 62.5% 25% / 0.0)", "rgba(24, 104, 24, 0)", +"hsl(150 62.5% 25% / 0.0)", "rgba(24, 104, 64, 0)", +"hsl(180 62.5% 25% / 0.0)", "rgba(24, 104, 104, 0)", +"hsl(210 62.5% 25% / 0.0)", "rgba(24, 64, 104, 0)", +"hsl(240 62.5% 25% / 0.0)", "rgba(24, 24, 104, 0)", +"hsl(270 62.5% 25% / 0.0)", "rgba(64, 24, 104, 0)", +"hsl(300 62.5% 25% / 0.0)", "rgba(104, 24, 104, 0)", +"hsl(330 62.5% 25% / 0.0)", "rgba(104, 24, 64, 0)", +"hsl(0 75% 25% / 0.0)", "rgba(112, 16, 16, 0)", +"hsl(30 75% 25% / 0.0)", "rgba(112, 64, 16, 0)", +"hsl(60 75% 25% / 0.0)", "rgba(112, 112, 16, 0)", +"hsl(90 75% 25% / 0.0)", "rgba(64, 112, 16, 0)", +"hsl(120 75% 25% / 0.0)", "rgba(16, 112, 16, 0)", +"hsl(150 75% 25% / 0.0)", "rgba(16, 112, 64, 0)", +"hsl(180 75% 25% / 0.0)", "rgba(16, 112, 112, 0)", +"hsl(210 75% 25% / 0.0)", "rgba(16, 64, 112, 0)", +"hsl(240 75% 25% / 0.0)", "rgba(16, 16, 112, 0)", +"hsl(270 75% 25% / 0.0)", "rgba(64, 16, 112, 0)", +"hsl(300 75% 25% / 0.0)", "rgba(112, 16, 112, 0)", +"hsl(330 75% 25% / 0.0)", "rgba(112, 16, 64, 0)", +"hsl(0 87.5% 25% / 0.0)", "rgba(120, 8, 8, 0)", +"hsl(30 87.5% 25% / 0.0)", "rgba(120, 64, 8, 0)", +"hsl(60 87.5% 25% / 0.0)", "rgba(120, 120, 8, 0)", +"hsl(90 87.5% 25% / 0.0)", "rgba(64, 120, 8, 0)", +"hsl(120 87.5% 25% / 0.0)", "rgba(8, 120, 8, 0)", +"hsl(150 87.5% 25% / 0.0)", "rgba(8, 120, 64, 0)", +"hsl(180 87.5% 25% / 0.0)", "rgba(8, 120, 120, 0)", +"hsl(210 87.5% 25% / 0.0)", "rgba(8, 64, 120, 0)", +"hsl(240 87.5% 25% / 0.0)", "rgba(8, 8, 120, 0)", +"hsl(270 87.5% 25% / 0.0)", "rgba(64, 8, 120, 0)", +"hsl(300 87.5% 25% / 0.0)", "rgba(120, 8, 120, 0)", +"hsl(330 87.5% 25% / 0.0)", "rgba(120, 8, 64, 0)", +"hsl(0 100% 25% / 0.0)", "rgba(128, 0, 0, 0)", +"hsl(30 100% 25% / 0.0)", "rgba(128, 64, 0, 0)", +"hsl(60 100% 25% / 0.0)", "rgba(128, 128, 0, 0)", +"hsl(90 100% 25% / 0.0)", "rgba(64, 128, 0, 0)", +"hsl(120 100% 25% / 0.0)", "rgba(0, 128, 0, 0)", +"hsl(150 100% 25% / 0.0)", "rgba(0, 128, 64, 0)", +"hsl(180 100% 25% / 0.0)", "rgba(0, 128, 128, 0)", +"hsl(210 100% 25% / 0.0)", "rgba(0, 64, 128, 0)", +"hsl(240 100% 25% / 0.0)", "rgba(0, 0, 128, 0)", +"hsl(270 100% 25% / 0.0)", "rgba(64, 0, 128, 0)", +"hsl(300 100% 25% / 0.0)", "rgba(128, 0, 128, 0)", +"hsl(330 100% 25% / 0.0)", "rgba(128, 0, 64, 0)", +"hsl(0 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(30 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(60 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(90 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(120 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(150 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(180 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(210 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(240 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(270 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(300 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(330 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsl(0 12.5% 37.5% / 0.0)", "rgba(108, 84, 84, 0)", +"hsl(30 12.5% 37.5% / 0.0)", "rgba(108, 96, 84, 0)", +"hsl(60 12.5% 37.5% / 0.0)", "rgba(108, 108, 84, 0)", +"hsl(90 12.5% 37.5% / 0.0)", "rgba(96, 108, 84, 0)", +"hsl(120 12.5% 37.5% / 0.0)", "rgba(84, 108, 84, 0)", +"hsl(150 12.5% 37.5% / 0.0)", "rgba(84, 108, 96, 0)", +"hsl(180 12.5% 37.5% / 0.0)", "rgba(84, 108, 108, 0)", +"hsl(210 12.5% 37.5% / 0.0)", "rgba(84, 96, 108, 0)", +"hsl(240 12.5% 37.5% / 0.0)", "rgba(84, 84, 108, 0)", +"hsl(270 12.5% 37.5% / 0.0)", "rgba(96, 84, 108, 0)", +"hsl(300 12.5% 37.5% / 0.0)", "rgba(108, 84, 108, 0)", +"hsl(330 12.5% 37.5% / 0.0)", "rgba(108, 84, 96, 0)", +"hsl(0 25% 37.5% / 0.0)", "rgba(120, 72, 72, 0)", +"hsl(30 25% 37.5% / 0.0)", "rgba(120, 96, 72, 0)", +"hsl(60 25% 37.5% / 0.0)", "rgba(120, 120, 72, 0)", +"hsl(90 25% 37.5% / 0.0)", "rgba(96, 120, 72, 0)", +"hsl(120 25% 37.5% / 0.0)", "rgba(72, 120, 72, 0)", +"hsl(150 25% 37.5% / 0.0)", "rgba(72, 120, 96, 0)", +"hsl(180 25% 37.5% / 0.0)", "rgba(72, 120, 120, 0)", +"hsl(210 25% 37.5% / 0.0)", "rgba(72, 96, 120, 0)", +"hsl(240 25% 37.5% / 0.0)", "rgba(72, 72, 120, 0)", +"hsl(270 25% 37.5% / 0.0)", "rgba(96, 72, 120, 0)", +"hsl(300 25% 37.5% / 0.0)", "rgba(120, 72, 120, 0)", +"hsl(330 25% 37.5% / 0.0)", "rgba(120, 72, 96, 0)", +"hsl(0 37.5% 37.5% / 0.0)", "rgba(131, 60, 60, 0)", +"hsl(30 37.5% 37.5% / 0.0)", "rgba(131, 96, 60, 0)", +"hsl(60 37.5% 37.5% / 0.0)", "rgba(131, 131, 60, 0)", +"hsl(90 37.5% 37.5% / 0.0)", "rgba(96, 131, 60, 0)", +"hsl(120 37.5% 37.5% / 0.0)", "rgba(60, 131, 60, 0)", +"hsl(150 37.5% 37.5% / 0.0)", "rgba(60, 131, 96, 0)", +"hsl(180 37.5% 37.5% / 0.0)", "rgba(60, 131, 131, 0)", +"hsl(210 37.5% 37.5% / 0.0)", "rgba(60, 96, 131, 0)", +"hsl(240 37.5% 37.5% / 0.0)", "rgba(60, 60, 131, 0)", +"hsl(270 37.5% 37.5% / 0.0)", "rgba(96, 60, 131, 0)", +"hsl(300 37.5% 37.5% / 0.0)", "rgba(131, 60, 131, 0)", +"hsl(330 37.5% 37.5% / 0.0)", "rgba(131, 60, 96, 0)", +"hsl(0 50% 37.5% / 0.0)", "rgba(143, 48, 48, 0)", +"hsl(30 50% 37.5% / 0.0)", "rgba(143, 96, 48, 0)", +"hsl(60 50% 37.5% / 0.0)", "rgba(143, 143, 48, 0)", +"hsl(90 50% 37.5% / 0.0)", "rgba(96, 143, 48, 0)", +"hsl(120 50% 37.5% / 0.0)", "rgba(48, 143, 48, 0)", +"hsl(150 50% 37.5% / 0.0)", "rgba(48, 143, 96, 0)", +"hsl(180 50% 37.5% / 0.0)", "rgba(48, 143, 143, 0)", +"hsl(210 50% 37.5% / 0.0)", "rgba(48, 96, 143, 0)", +"hsl(240 50% 37.5% / 0.0)", "rgba(48, 48, 143, 0)", +"hsl(270 50% 37.5% / 0.0)", "rgba(96, 48, 143, 0)", +"hsl(300 50% 37.5% / 0.0)", "rgba(143, 48, 143, 0)", +"hsl(330 50% 37.5% / 0.0)", "rgba(143, 48, 96, 0)", +"hsl(0 62.5% 37.5% / 0.0)", "rgba(155, 36, 36, 0)", +"hsl(30 62.5% 37.5% / 0.0)", "rgba(155, 96, 36, 0)", +"hsl(60 62.5% 37.5% / 0.0)", "rgba(155, 155, 36, 0)", +"hsl(90 62.5% 37.5% / 0.0)", "rgba(96, 155, 36, 0)", +"hsl(120 62.5% 37.5% / 0.0)", "rgba(36, 155, 36, 0)", +"hsl(150 62.5% 37.5% / 0.0)", "rgba(36, 155, 96, 0)", +"hsl(180 62.5% 37.5% / 0.0)", "rgba(36, 155, 155, 0)", +"hsl(210 62.5% 37.5% / 0.0)", "rgba(36, 96, 155, 0)", +"hsl(240 62.5% 37.5% / 0.0)", "rgba(36, 36, 155, 0)", +"hsl(270 62.5% 37.5% / 0.0)", "rgba(96, 36, 155, 0)", +"hsl(300 62.5% 37.5% / 0.0)", "rgba(155, 36, 155, 0)", +"hsl(330 62.5% 37.5% / 0.0)", "rgba(155, 36, 96, 0)", +"hsl(0 75% 37.5% / 0.0)", "rgba(167, 24, 24, 0)", +"hsl(30 75% 37.5% / 0.0)", "rgba(167, 96, 24, 0)", +"hsl(60 75% 37.5% / 0.0)", "rgba(167, 167, 24, 0)", +"hsl(90 75% 37.5% / 0.0)", "rgba(96, 167, 24, 0)", +"hsl(120 75% 37.5% / 0.0)", "rgba(24, 167, 24, 0)", +"hsl(150 75% 37.5% / 0.0)", "rgba(24, 167, 96, 0)", +"hsl(180 75% 37.5% / 0.0)", "rgba(24, 167, 167, 0)", +"hsl(210 75% 37.5% / 0.0)", "rgba(24, 96, 167, 0)", +"hsl(240 75% 37.5% / 0.0)", "rgba(24, 24, 167, 0)", +"hsl(270 75% 37.5% / 0.0)", "rgba(96, 24, 167, 0)", +"hsl(300 75% 37.5% / 0.0)", "rgba(167, 24, 167, 0)", +"hsl(330 75% 37.5% / 0.0)", "rgba(167, 24, 96, 0)", +"hsl(0 87.5% 37.5% / 0.0)", "rgba(179, 12, 12, 0)", +"hsl(30 87.5% 37.5% / 0.0)", "rgba(179, 96, 12, 0)", +"hsl(60 87.5% 37.5% / 0.0)", "rgba(179, 179, 12, 0)", +"hsl(90 87.5% 37.5% / 0.0)", "rgba(96, 179, 12, 0)", +"hsl(120 87.5% 37.5% / 0.0)", "rgba(12, 179, 12, 0)", +"hsl(150 87.5% 37.5% / 0.0)", "rgba(12, 179, 96, 0)", +"hsl(180 87.5% 37.5% / 0.0)", "rgba(12, 179, 179, 0)", +"hsl(210 87.5% 37.5% / 0.0)", "rgba(12, 96, 179, 0)", +"hsl(240 87.5% 37.5% / 0.0)", "rgba(12, 12, 179, 0)", +"hsl(270 87.5% 37.5% / 0.0)", "rgba(96, 12, 179, 0)", +"hsl(300 87.5% 37.5% / 0.0)", "rgba(179, 12, 179, 0)", +"hsl(330 87.5% 37.5% / 0.0)", "rgba(179, 12, 96, 0)", +"hsl(0 100% 37.5% / 0.0)", "rgba(191, 0, 0, 0)", +"hsl(30 100% 37.5% / 0.0)", "rgba(191, 96, 0, 0)", +"hsl(60 100% 37.5% / 0.0)", "rgba(191, 191, 0, 0)", +"hsl(90 100% 37.5% / 0.0)", "rgba(96, 191, 0, 0)", +"hsl(120 100% 37.5% / 0.0)", "rgba(0, 191, 0, 0)", +"hsl(150 100% 37.5% / 0.0)", "rgba(0, 191, 96, 0)", +"hsl(180 100% 37.5% / 0.0)", "rgba(0, 191, 191, 0)", +"hsl(210 100% 37.5% / 0.0)", "rgba(0, 96, 191, 0)", +"hsl(240 100% 37.5% / 0.0)", "rgba(0, 0, 191, 0)", +"hsl(270 100% 37.5% / 0.0)", "rgba(96, 0, 191, 0)", +"hsl(300 100% 37.5% / 0.0)", "rgba(191, 0, 191, 0)", +"hsl(330 100% 37.5% / 0.0)", "rgba(191, 0, 96, 0)", +"hsl(0 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(30 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(60 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(90 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(120 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(150 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(180 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(210 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(240 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(270 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(300 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(330 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsl(0 12.5% 50% / 0.0)", "rgba(143, 112, 112, 0)", +"hsl(30 12.5% 50% / 0.0)", "rgba(143, 128, 112, 0)", +"hsl(60 12.5% 50% / 0.0)", "rgba(143, 143, 112, 0)", +"hsl(90 12.5% 50% / 0.0)", "rgba(128, 143, 112, 0)", +"hsl(120 12.5% 50% / 0.0)", "rgba(112, 143, 112, 0)", +"hsl(150 12.5% 50% / 0.0)", "rgba(112, 143, 128, 0)", +"hsl(180 12.5% 50% / 0.0)", "rgba(112, 143, 143, 0)", +"hsl(210 12.5% 50% / 0.0)", "rgba(112, 128, 143, 0)", +"hsl(240 12.5% 50% / 0.0)", "rgba(112, 112, 143, 0)", +"hsl(270 12.5% 50% / 0.0)", "rgba(128, 112, 143, 0)", +"hsl(300 12.5% 50% / 0.0)", "rgba(143, 112, 143, 0)", +"hsl(330 12.5% 50% / 0.0)", "rgba(143, 112, 128, 0)", +"hsl(0 25% 50% / 0.0)", "rgba(159, 96, 96, 0)", +"hsl(30 25% 50% / 0.0)", "rgba(159, 128, 96, 0)", +"hsl(60 25% 50% / 0.0)", "rgba(159, 159, 96, 0)", +"hsl(90 25% 50% / 0.0)", "rgba(128, 159, 96, 0)", +"hsl(120 25% 50% / 0.0)", "rgba(96, 159, 96, 0)", +"hsl(150 25% 50% / 0.0)", "rgba(96, 159, 128, 0)", +"hsl(180 25% 50% / 0.0)", "rgba(96, 159, 159, 0)", +"hsl(210 25% 50% / 0.0)", "rgba(96, 128, 159, 0)", +"hsl(240 25% 50% / 0.0)", "rgba(96, 96, 159, 0)", +"hsl(270 25% 50% / 0.0)", "rgba(128, 96, 159, 0)", +"hsl(300 25% 50% / 0.0)", "rgba(159, 96, 159, 0)", +"hsl(330 25% 50% / 0.0)", "rgba(159, 96, 128, 0)", +"hsl(0 37.5% 50% / 0.0)", "rgba(175, 80, 80, 0)", +"hsl(30 37.5% 50% / 0.0)", "rgba(175, 128, 80, 0)", +"hsl(60 37.5% 50% / 0.0)", "rgba(175, 175, 80, 0)", +"hsl(90 37.5% 50% / 0.0)", "rgba(128, 175, 80, 0)", +"hsl(120 37.5% 50% / 0.0)", "rgba(80, 175, 80, 0)", +"hsl(150 37.5% 50% / 0.0)", "rgba(80, 175, 128, 0)", +"hsl(180 37.5% 50% / 0.0)", "rgba(80, 175, 175, 0)", +"hsl(210 37.5% 50% / 0.0)", "rgba(80, 128, 175, 0)", +"hsl(240 37.5% 50% / 0.0)", "rgba(80, 80, 175, 0)", +"hsl(270 37.5% 50% / 0.0)", "rgba(128, 80, 175, 0)", +"hsl(300 37.5% 50% / 0.0)", "rgba(175, 80, 175, 0)", +"hsl(330 37.5% 50% / 0.0)", "rgba(175, 80, 128, 0)", +"hsl(0 50% 50% / 0.0)", "rgba(191, 64, 64, 0)", +"hsl(30 50% 50% / 0.0)", "rgba(191, 128, 64, 0)", +"hsl(60 50% 50% / 0.0)", "rgba(191, 191, 64, 0)", +"hsl(90 50% 50% / 0.0)", "rgba(128, 191, 64, 0)", +"hsl(120 50% 50% / 0.0)", "rgba(64, 191, 64, 0)", +"hsl(150 50% 50% / 0.0)", "rgba(64, 191, 128, 0)", +"hsl(180 50% 50% / 0.0)", "rgba(64, 191, 191, 0)", +"hsl(210 50% 50% / 0.0)", "rgba(64, 128, 191, 0)", +"hsl(240 50% 50% / 0.0)", "rgba(64, 64, 191, 0)", +"hsl(270 50% 50% / 0.0)", "rgba(128, 64, 191, 0)", +"hsl(300 50% 50% / 0.0)", "rgba(191, 64, 191, 0)", +"hsl(330 50% 50% / 0.0)", "rgba(191, 64, 128, 0)", +"hsl(0 62.5% 50% / 0.0)", "rgba(207, 48, 48, 0)", +"hsl(30 62.5% 50% / 0.0)", "rgba(207, 128, 48, 0)", +"hsl(60 62.5% 50% / 0.0)", "rgba(207, 207, 48, 0)", +"hsl(90 62.5% 50% / 0.0)", "rgba(128, 207, 48, 0)", +"hsl(120 62.5% 50% / 0.0)", "rgba(48, 207, 48, 0)", +"hsl(150 62.5% 50% / 0.0)", "rgba(48, 207, 128, 0)", +"hsl(180 62.5% 50% / 0.0)", "rgba(48, 207, 207, 0)", +"hsl(210 62.5% 50% / 0.0)", "rgba(48, 128, 207, 0)", +"hsl(240 62.5% 50% / 0.0)", "rgba(48, 48, 207, 0)", +"hsl(270 62.5% 50% / 0.0)", "rgba(128, 48, 207, 0)", +"hsl(300 62.5% 50% / 0.0)", "rgba(207, 48, 207, 0)", +"hsl(330 62.5% 50% / 0.0)", "rgba(207, 48, 128, 0)", +"hsl(0 75% 50% / 0.0)", "rgba(223, 32, 32, 0)", +"hsl(30 75% 50% / 0.0)", "rgba(223, 128, 32, 0)", +"hsl(60 75% 50% / 0.0)", "rgba(223, 223, 32, 0)", +"hsl(90 75% 50% / 0.0)", "rgba(128, 223, 32, 0)", +"hsl(120 75% 50% / 0.0)", "rgba(32, 223, 32, 0)", +"hsl(150 75% 50% / 0.0)", "rgba(32, 223, 128, 0)", +"hsl(180 75% 50% / 0.0)", "rgba(32, 223, 223, 0)", +"hsl(210 75% 50% / 0.0)", "rgba(32, 128, 223, 0)", +"hsl(240 75% 50% / 0.0)", "rgba(32, 32, 223, 0)", +"hsl(270 75% 50% / 0.0)", "rgba(128, 32, 223, 0)", +"hsl(300 75% 50% / 0.0)", "rgba(223, 32, 223, 0)", +"hsl(330 75% 50% / 0.0)", "rgba(223, 32, 128, 0)", +"hsl(0 87.5% 50% / 0.0)", "rgba(239, 16, 16, 0)", +"hsl(30 87.5% 50% / 0.0)", "rgba(239, 128, 16, 0)", +"hsl(60 87.5% 50% / 0.0)", "rgba(239, 239, 16, 0)", +"hsl(90 87.5% 50% / 0.0)", "rgba(128, 239, 16, 0)", +"hsl(120 87.5% 50% / 0.0)", "rgba(16, 239, 16, 0)", +"hsl(150 87.5% 50% / 0.0)", "rgba(16, 239, 128, 0)", +"hsl(180 87.5% 50% / 0.0)", "rgba(16, 239, 239, 0)", +"hsl(210 87.5% 50% / 0.0)", "rgba(16, 128, 239, 0)", +"hsl(240 87.5% 50% / 0.0)", "rgba(16, 16, 239, 0)", +"hsl(270 87.5% 50% / 0.0)", "rgba(128, 16, 239, 0)", +"hsl(300 87.5% 50% / 0.0)", "rgba(239, 16, 239, 0)", +"hsl(330 87.5% 50% / 0.0)", "rgba(239, 16, 128, 0)", +"hsl(0 100% 50% / 0.0)", "rgba(255, 0, 0, 0)", +"hsl(30 100% 50% / 0.0)", "rgba(255, 128, 0, 0)", +"hsl(60 100% 50% / 0.0)", "rgba(255, 255, 0, 0)", +"hsl(90 100% 50% / 0.0)", "rgba(128, 255, 0, 0)", +"hsl(120 100% 50% / 0.0)", "rgba(0, 255, 0, 0)", +"hsl(150 100% 50% / 0.0)", "rgba(0, 255, 128, 0)", +"hsl(180 100% 50% / 0.0)", "rgba(0, 255, 255, 0)", +"hsl(210 100% 50% / 0.0)", "rgba(0, 128, 255, 0)", +"hsl(240 100% 50% / 0.0)", "rgba(0, 0, 255, 0)", +"hsl(270 100% 50% / 0.0)", "rgba(128, 0, 255, 0)", +"hsl(300 100% 50% / 0.0)", "rgba(255, 0, 255, 0)", +"hsl(330 100% 50% / 0.0)", "rgba(255, 0, 128, 0)", +"hsl(0 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(30 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(60 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(90 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(120 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(150 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(180 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(210 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(240 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(270 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(300 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(330 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsl(0 12.5% 62.5% / 0.0)", "rgba(171, 147, 147, 0)", +"hsl(30 12.5% 62.5% / 0.0)", "rgba(171, 159, 147, 0)", +"hsl(60 12.5% 62.5% / 0.0)", "rgba(171, 171, 147, 0)", +"hsl(90 12.5% 62.5% / 0.0)", "rgba(159, 171, 147, 0)", +"hsl(120 12.5% 62.5% / 0.0)", "rgba(147, 171, 147, 0)", +"hsl(150 12.5% 62.5% / 0.0)", "rgba(147, 171, 159, 0)", +"hsl(180 12.5% 62.5% / 0.0)", "rgba(147, 171, 171, 0)", +"hsl(210 12.5% 62.5% / 0.0)", "rgba(147, 159, 171, 0)", +"hsl(240 12.5% 62.5% / 0.0)", "rgba(147, 147, 171, 0)", +"hsl(270 12.5% 62.5% / 0.0)", "rgba(159, 147, 171, 0)", +"hsl(300 12.5% 62.5% / 0.0)", "rgba(171, 147, 171, 0)", +"hsl(330 12.5% 62.5% / 0.0)", "rgba(171, 147, 159, 0)", +"hsl(0 25% 62.5% / 0.0)", "rgba(183, 135, 135, 0)", +"hsl(30 25% 62.5% / 0.0)", "rgba(183, 159, 135, 0)", +"hsl(60 25% 62.5% / 0.0)", "rgba(183, 183, 135, 0)", +"hsl(90 25% 62.5% / 0.0)", "rgba(159, 183, 135, 0)", +"hsl(120 25% 62.5% / 0.0)", "rgba(135, 183, 135, 0)", +"hsl(150 25% 62.5% / 0.0)", "rgba(135, 183, 159, 0)", +"hsl(180 25% 62.5% / 0.0)", "rgba(135, 183, 183, 0)", +"hsl(210 25% 62.5% / 0.0)", "rgba(135, 159, 183, 0)", +"hsl(240 25% 62.5% / 0.0)", "rgba(135, 135, 183, 0)", +"hsl(270 25% 62.5% / 0.0)", "rgba(159, 135, 183, 0)", +"hsl(300 25% 62.5% / 0.0)", "rgba(183, 135, 183, 0)", +"hsl(330 25% 62.5% / 0.0)", "rgba(183, 135, 159, 0)", +"hsl(0 37.5% 62.5% / 0.0)", "rgba(195, 124, 124, 0)", +"hsl(30 37.5% 62.5% / 0.0)", "rgba(195, 159, 124, 0)", +"hsl(60 37.5% 62.5% / 0.0)", "rgba(195, 195, 124, 0)", +"hsl(90 37.5% 62.5% / 0.0)", "rgba(159, 195, 124, 0)", +"hsl(120 37.5% 62.5% / 0.0)", "rgba(124, 195, 124, 0)", +"hsl(150 37.5% 62.5% / 0.0)", "rgba(124, 195, 159, 0)", +"hsl(180 37.5% 62.5% / 0.0)", "rgba(124, 195, 195, 0)", +"hsl(210 37.5% 62.5% / 0.0)", "rgba(124, 159, 195, 0)", +"hsl(240 37.5% 62.5% / 0.0)", "rgba(124, 124, 195, 0)", +"hsl(270 37.5% 62.5% / 0.0)", "rgba(159, 124, 195, 0)", +"hsl(300 37.5% 62.5% / 0.0)", "rgba(195, 124, 195, 0)", +"hsl(330 37.5% 62.5% / 0.0)", "rgba(195, 124, 159, 0)", +"hsl(0 50% 62.5% / 0.0)", "rgba(207, 112, 112, 0)", +"hsl(30 50% 62.5% / 0.0)", "rgba(207, 159, 112, 0)", +"hsl(60 50% 62.5% / 0.0)", "rgba(207, 207, 112, 0)", +"hsl(90 50% 62.5% / 0.0)", "rgba(159, 207, 112, 0)", +"hsl(120 50% 62.5% / 0.0)", "rgba(112, 207, 112, 0)", +"hsl(150 50% 62.5% / 0.0)", "rgba(112, 207, 159, 0)", +"hsl(180 50% 62.5% / 0.0)", "rgba(112, 207, 207, 0)", +"hsl(210 50% 62.5% / 0.0)", "rgba(112, 159, 207, 0)", +"hsl(240 50% 62.5% / 0.0)", "rgba(112, 112, 207, 0)", +"hsl(270 50% 62.5% / 0.0)", "rgba(159, 112, 207, 0)", +"hsl(300 50% 62.5% / 0.0)", "rgba(207, 112, 207, 0)", +"hsl(330 50% 62.5% / 0.0)", "rgba(207, 112, 159, 0)", +"hsl(0 62.5% 62.5% / 0.0)", "rgba(219, 100, 100, 0)", +"hsl(30 62.5% 62.5% / 0.0)", "rgba(219, 159, 100, 0)", +"hsl(60 62.5% 62.5% / 0.0)", "rgba(219, 219, 100, 0)", +"hsl(90 62.5% 62.5% / 0.0)", "rgba(159, 219, 100, 0)", +"hsl(120 62.5% 62.5% / 0.0)", "rgba(100, 219, 100, 0)", +"hsl(150 62.5% 62.5% / 0.0)", "rgba(100, 219, 159, 0)", +"hsl(180 62.5% 62.5% / 0.0)", "rgba(100, 219, 219, 0)", +"hsl(210 62.5% 62.5% / 0.0)", "rgba(100, 159, 219, 0)", +"hsl(240 62.5% 62.5% / 0.0)", "rgba(100, 100, 219, 0)", +"hsl(270 62.5% 62.5% / 0.0)", "rgba(159, 100, 219, 0)", +"hsl(300 62.5% 62.5% / 0.0)", "rgba(219, 100, 219, 0)", +"hsl(330 62.5% 62.5% / 0.0)", "rgba(219, 100, 159, 0)", +"hsl(0 75% 62.5% / 0.0)", "rgba(231, 88, 88, 0)", +"hsl(30 75% 62.5% / 0.0)", "rgba(231, 159, 88, 0)", +"hsl(60 75% 62.5% / 0.0)", "rgba(231, 231, 88, 0)", +"hsl(90 75% 62.5% / 0.0)", "rgba(159, 231, 88, 0)", +"hsl(120 75% 62.5% / 0.0)", "rgba(88, 231, 88, 0)", +"hsl(150 75% 62.5% / 0.0)", "rgba(88, 231, 159, 0)", +"hsl(180 75% 62.5% / 0.0)", "rgba(88, 231, 231, 0)", +"hsl(210 75% 62.5% / 0.0)", "rgba(88, 159, 231, 0)", +"hsl(240 75% 62.5% / 0.0)", "rgba(88, 88, 231, 0)", +"hsl(270 75% 62.5% / 0.0)", "rgba(159, 88, 231, 0)", +"hsl(300 75% 62.5% / 0.0)", "rgba(231, 88, 231, 0)", +"hsl(330 75% 62.5% / 0.0)", "rgba(231, 88, 159, 0)", +"hsl(0 87.5% 62.5% / 0.0)", "rgba(243, 76, 76, 0)", +"hsl(30 87.5% 62.5% / 0.0)", "rgba(243, 159, 76, 0)", +"hsl(60 87.5% 62.5% / 0.0)", "rgba(243, 243, 76, 0)", +"hsl(90 87.5% 62.5% / 0.0)", "rgba(159, 243, 76, 0)", +"hsl(120 87.5% 62.5% / 0.0)", "rgba(76, 243, 76, 0)", +"hsl(150 87.5% 62.5% / 0.0)", "rgba(76, 243, 159, 0)", +"hsl(180 87.5% 62.5% / 0.0)", "rgba(76, 243, 243, 0)", +"hsl(210 87.5% 62.5% / 0.0)", "rgba(76, 159, 243, 0)", +"hsl(240 87.5% 62.5% / 0.0)", "rgba(76, 76, 243, 0)", +"hsl(270 87.5% 62.5% / 0.0)", "rgba(159, 76, 243, 0)", +"hsl(300 87.5% 62.5% / 0.0)", "rgba(243, 76, 243, 0)", +"hsl(330 87.5% 62.5% / 0.0)", "rgba(243, 76, 159, 0)", +"hsl(0 100% 62.5% / 0.0)", "rgba(255, 64, 64, 0)", +"hsl(30 100% 62.5% / 0.0)", "rgba(255, 159, 64, 0)", +"hsl(60 100% 62.5% / 0.0)", "rgba(255, 255, 64, 0)", +"hsl(90 100% 62.5% / 0.0)", "rgba(159, 255, 64, 0)", +"hsl(120 100% 62.5% / 0.0)", "rgba(64, 255, 64, 0)", +"hsl(150 100% 62.5% / 0.0)", "rgba(64, 255, 159, 0)", +"hsl(180 100% 62.5% / 0.0)", "rgba(64, 255, 255, 0)", +"hsl(210 100% 62.5% / 0.0)", "rgba(64, 159, 255, 0)", +"hsl(240 100% 62.5% / 0.0)", "rgba(64, 64, 255, 0)", +"hsl(270 100% 62.5% / 0.0)", "rgba(159, 64, 255, 0)", +"hsl(300 100% 62.5% / 0.0)", "rgba(255, 64, 255, 0)", +"hsl(330 100% 62.5% / 0.0)", "rgba(255, 64, 159, 0)", +"hsl(0 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(30 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(60 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(90 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(120 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(150 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(180 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(210 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(240 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(270 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(300 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(330 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsl(0 12.5% 75% / 0.0)", "rgba(199, 183, 183, 0)", +"hsl(30 12.5% 75% / 0.0)", "rgba(199, 191, 183, 0)", +"hsl(60 12.5% 75% / 0.0)", "rgba(199, 199, 183, 0)", +"hsl(90 12.5% 75% / 0.0)", "rgba(191, 199, 183, 0)", +"hsl(120 12.5% 75% / 0.0)", "rgba(183, 199, 183, 0)", +"hsl(150 12.5% 75% / 0.0)", "rgba(183, 199, 191, 0)", +"hsl(180 12.5% 75% / 0.0)", "rgba(183, 199, 199, 0)", +"hsl(210 12.5% 75% / 0.0)", "rgba(183, 191, 199, 0)", +"hsl(240 12.5% 75% / 0.0)", "rgba(183, 183, 199, 0)", +"hsl(270 12.5% 75% / 0.0)", "rgba(191, 183, 199, 0)", +"hsl(300 12.5% 75% / 0.0)", "rgba(199, 183, 199, 0)", +"hsl(330 12.5% 75% / 0.0)", "rgba(199, 183, 191, 0)", +"hsl(0 25% 75% / 0.0)", "rgba(207, 175, 175, 0)", +"hsl(30 25% 75% / 0.0)", "rgba(207, 191, 175, 0)", +"hsl(60 25% 75% / 0.0)", "rgba(207, 207, 175, 0)", +"hsl(90 25% 75% / 0.0)", "rgba(191, 207, 175, 0)", +"hsl(120 25% 75% / 0.0)", "rgba(175, 207, 175, 0)", +"hsl(150 25% 75% / 0.0)", "rgba(175, 207, 191, 0)", +"hsl(180 25% 75% / 0.0)", "rgba(175, 207, 207, 0)", +"hsl(210 25% 75% / 0.0)", "rgba(175, 191, 207, 0)", +"hsl(240 25% 75% / 0.0)", "rgba(175, 175, 207, 0)", +"hsl(270 25% 75% / 0.0)", "rgba(191, 175, 207, 0)", +"hsl(300 25% 75% / 0.0)", "rgba(207, 175, 207, 0)", +"hsl(330 25% 75% / 0.0)", "rgba(207, 175, 191, 0)", +"hsl(0 37.5% 75% / 0.0)", "rgba(215, 167, 167, 0)", +"hsl(30 37.5% 75% / 0.0)", "rgba(215, 191, 167, 0)", +"hsl(60 37.5% 75% / 0.0)", "rgba(215, 215, 167, 0)", +"hsl(90 37.5% 75% / 0.0)", "rgba(191, 215, 167, 0)", +"hsl(120 37.5% 75% / 0.0)", "rgba(167, 215, 167, 0)", +"hsl(150 37.5% 75% / 0.0)", "rgba(167, 215, 191, 0)", +"hsl(180 37.5% 75% / 0.0)", "rgba(167, 215, 215, 0)", +"hsl(210 37.5% 75% / 0.0)", "rgba(167, 191, 215, 0)", +"hsl(240 37.5% 75% / 0.0)", "rgba(167, 167, 215, 0)", +"hsl(270 37.5% 75% / 0.0)", "rgba(191, 167, 215, 0)", +"hsl(300 37.5% 75% / 0.0)", "rgba(215, 167, 215, 0)", +"hsl(330 37.5% 75% / 0.0)", "rgba(215, 167, 191, 0)", +"hsl(0 50% 75% / 0.0)", "rgba(223, 159, 159, 0)", +"hsl(30 50% 75% / 0.0)", "rgba(223, 191, 159, 0)", +"hsl(60 50% 75% / 0.0)", "rgba(223, 223, 159, 0)", +"hsl(90 50% 75% / 0.0)", "rgba(191, 223, 159, 0)", +"hsl(120 50% 75% / 0.0)", "rgba(159, 223, 159, 0)", +"hsl(150 50% 75% / 0.0)", "rgba(159, 223, 191, 0)", +"hsl(180 50% 75% / 0.0)", "rgba(159, 223, 223, 0)", +"hsl(210 50% 75% / 0.0)", "rgba(159, 191, 223, 0)", +"hsl(240 50% 75% / 0.0)", "rgba(159, 159, 223, 0)", +"hsl(270 50% 75% / 0.0)", "rgba(191, 159, 223, 0)", +"hsl(300 50% 75% / 0.0)", "rgba(223, 159, 223, 0)", +"hsl(330 50% 75% / 0.0)", "rgba(223, 159, 191, 0)", +"hsl(0 62.5% 75% / 0.0)", "rgba(231, 151, 151, 0)", +"hsl(30 62.5% 75% / 0.0)", "rgba(231, 191, 151, 0)", +"hsl(60 62.5% 75% / 0.0)", "rgba(231, 231, 151, 0)", +"hsl(90 62.5% 75% / 0.0)", "rgba(191, 231, 151, 0)", +"hsl(120 62.5% 75% / 0.0)", "rgba(151, 231, 151, 0)", +"hsl(150 62.5% 75% / 0.0)", "rgba(151, 231, 191, 0)", +"hsl(180 62.5% 75% / 0.0)", "rgba(151, 231, 231, 0)", +"hsl(210 62.5% 75% / 0.0)", "rgba(151, 191, 231, 0)", +"hsl(240 62.5% 75% / 0.0)", "rgba(151, 151, 231, 0)", +"hsl(270 62.5% 75% / 0.0)", "rgba(191, 151, 231, 0)", +"hsl(300 62.5% 75% / 0.0)", "rgba(231, 151, 231, 0)", +"hsl(330 62.5% 75% / 0.0)", "rgba(231, 151, 191, 0)", +"hsl(0 75% 75% / 0.0)", "rgba(239, 143, 143, 0)", +"hsl(30 75% 75% / 0.0)", "rgba(239, 191, 143, 0)", +"hsl(60 75% 75% / 0.0)", "rgba(239, 239, 143, 0)", +"hsl(90 75% 75% / 0.0)", "rgba(191, 239, 143, 0)", +"hsl(120 75% 75% / 0.0)", "rgba(143, 239, 143, 0)", +"hsl(150 75% 75% / 0.0)", "rgba(143, 239, 191, 0)", +"hsl(180 75% 75% / 0.0)", "rgba(143, 239, 239, 0)", +"hsl(210 75% 75% / 0.0)", "rgba(143, 191, 239, 0)", +"hsl(240 75% 75% / 0.0)", "rgba(143, 143, 239, 0)", +"hsl(270 75% 75% / 0.0)", "rgba(191, 143, 239, 0)", +"hsl(300 75% 75% / 0.0)", "rgba(239, 143, 239, 0)", +"hsl(330 75% 75% / 0.0)", "rgba(239, 143, 191, 0)", +"hsl(0 87.5% 75% / 0.0)", "rgba(247, 135, 135, 0)", +"hsl(30 87.5% 75% / 0.0)", "rgba(247, 191, 135, 0)", +"hsl(60 87.5% 75% / 0.0)", "rgba(247, 247, 135, 0)", +"hsl(90 87.5% 75% / 0.0)", "rgba(191, 247, 135, 0)", +"hsl(120 87.5% 75% / 0.0)", "rgba(135, 247, 135, 0)", +"hsl(150 87.5% 75% / 0.0)", "rgba(135, 247, 191, 0)", +"hsl(180 87.5% 75% / 0.0)", "rgba(135, 247, 247, 0)", +"hsl(210 87.5% 75% / 0.0)", "rgba(135, 191, 247, 0)", +"hsl(240 87.5% 75% / 0.0)", "rgba(135, 135, 247, 0)", +"hsl(270 87.5% 75% / 0.0)", "rgba(191, 135, 247, 0)", +"hsl(300 87.5% 75% / 0.0)", "rgba(247, 135, 247, 0)", +"hsl(330 87.5% 75% / 0.0)", "rgba(247, 135, 191, 0)", +"hsl(0 100% 75% / 0.0)", "rgba(255, 128, 128, 0)", +"hsl(30 100% 75% / 0.0)", "rgba(255, 191, 128, 0)", +"hsl(60 100% 75% / 0.0)", "rgba(255, 255, 128, 0)", +"hsl(90 100% 75% / 0.0)", "rgba(191, 255, 128, 0)", +"hsl(120 100% 75% / 0.0)", "rgba(128, 255, 128, 0)", +"hsl(150 100% 75% / 0.0)", "rgba(128, 255, 191, 0)", +"hsl(180 100% 75% / 0.0)", "rgba(128, 255, 255, 0)", +"hsl(210 100% 75% / 0.0)", "rgba(128, 191, 255, 0)", +"hsl(240 100% 75% / 0.0)", "rgba(128, 128, 255, 0)", +"hsl(270 100% 75% / 0.0)", "rgba(191, 128, 255, 0)", +"hsl(300 100% 75% / 0.0)", "rgba(255, 128, 255, 0)", +"hsl(330 100% 75% / 0.0)", "rgba(255, 128, 191, 0)", +"hsl(0 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(30 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(60 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(90 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(120 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(150 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(180 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(210 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(240 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(270 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(300 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(330 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsl(0 12.5% 87.5% / 0.0)", "rgba(227, 219, 219, 0)", +"hsl(30 12.5% 87.5% / 0.0)", "rgba(227, 223, 219, 0)", +"hsl(60 12.5% 87.5% / 0.0)", "rgba(227, 227, 219, 0)", +"hsl(90 12.5% 87.5% / 0.0)", "rgba(223, 227, 219, 0)", +"hsl(120 12.5% 87.5% / 0.0)", "rgba(219, 227, 219, 0)", +"hsl(150 12.5% 87.5% / 0.0)", "rgba(219, 227, 223, 0)", +"hsl(180 12.5% 87.5% / 0.0)", "rgba(219, 227, 227, 0)", +"hsl(210 12.5% 87.5% / 0.0)", "rgba(219, 223, 227, 0)", +"hsl(240 12.5% 87.5% / 0.0)", "rgba(219, 219, 227, 0)", +"hsl(270 12.5% 87.5% / 0.0)", "rgba(223, 219, 227, 0)", +"hsl(300 12.5% 87.5% / 0.0)", "rgba(227, 219, 227, 0)", +"hsl(330 12.5% 87.5% / 0.0)", "rgba(227, 219, 223, 0)", +"hsl(0 25% 87.5% / 0.0)", "rgba(231, 215, 215, 0)", +"hsl(30 25% 87.5% / 0.0)", "rgba(231, 223, 215, 0)", +"hsl(60 25% 87.5% / 0.0)", "rgba(231, 231, 215, 0)", +"hsl(90 25% 87.5% / 0.0)", "rgba(223, 231, 215, 0)", +"hsl(120 25% 87.5% / 0.0)", "rgba(215, 231, 215, 0)", +"hsl(150 25% 87.5% / 0.0)", "rgba(215, 231, 223, 0)", +"hsl(180 25% 87.5% / 0.0)", "rgba(215, 231, 231, 0)", +"hsl(210 25% 87.5% / 0.0)", "rgba(215, 223, 231, 0)", +"hsl(240 25% 87.5% / 0.0)", "rgba(215, 215, 231, 0)", +"hsl(270 25% 87.5% / 0.0)", "rgba(223, 215, 231, 0)", +"hsl(300 25% 87.5% / 0.0)", "rgba(231, 215, 231, 0)", +"hsl(330 25% 87.5% / 0.0)", "rgba(231, 215, 223, 0)", +"hsl(0 37.5% 87.5% / 0.0)", "rgba(235, 211, 211, 0)", +"hsl(30 37.5% 87.5% / 0.0)", "rgba(235, 223, 211, 0)", +"hsl(60 37.5% 87.5% / 0.0)", "rgba(235, 235, 211, 0)", +"hsl(90 37.5% 87.5% / 0.0)", "rgba(223, 235, 211, 0)", +"hsl(120 37.5% 87.5% / 0.0)", "rgba(211, 235, 211, 0)", +"hsl(150 37.5% 87.5% / 0.0)", "rgba(211, 235, 223, 0)", +"hsl(180 37.5% 87.5% / 0.0)", "rgba(211, 235, 235, 0)", +"hsl(210 37.5% 87.5% / 0.0)", "rgba(211, 223, 235, 0)", +"hsl(240 37.5% 87.5% / 0.0)", "rgba(211, 211, 235, 0)", +"hsl(270 37.5% 87.5% / 0.0)", "rgba(223, 211, 235, 0)", +"hsl(300 37.5% 87.5% / 0.0)", "rgba(235, 211, 235, 0)", +"hsl(330 37.5% 87.5% / 0.0)", "rgba(235, 211, 223, 0)", +"hsl(0 50% 87.5% / 0.0)", "rgba(239, 207, 207, 0)", +"hsl(30 50% 87.5% / 0.0)", "rgba(239, 223, 207, 0)", +"hsl(60 50% 87.5% / 0.0)", "rgba(239, 239, 207, 0)", +"hsl(90 50% 87.5% / 0.0)", "rgba(223, 239, 207, 0)", +"hsl(120 50% 87.5% / 0.0)", "rgba(207, 239, 207, 0)", +"hsl(150 50% 87.5% / 0.0)", "rgba(207, 239, 223, 0)", +"hsl(180 50% 87.5% / 0.0)", "rgba(207, 239, 239, 0)", +"hsl(210 50% 87.5% / 0.0)", "rgba(207, 223, 239, 0)", +"hsl(240 50% 87.5% / 0.0)", "rgba(207, 207, 239, 0)", +"hsl(270 50% 87.5% / 0.0)", "rgba(223, 207, 239, 0)", +"hsl(300 50% 87.5% / 0.0)", "rgba(239, 207, 239, 0)", +"hsl(330 50% 87.5% / 0.0)", "rgba(239, 207, 223, 0)", +"hsl(0 62.5% 87.5% / 0.0)", "rgba(243, 203, 203, 0)", +"hsl(30 62.5% 87.5% / 0.0)", "rgba(243, 223, 203, 0)", +"hsl(60 62.5% 87.5% / 0.0)", "rgba(243, 243, 203, 0)", +"hsl(90 62.5% 87.5% / 0.0)", "rgba(223, 243, 203, 0)", +"hsl(120 62.5% 87.5% / 0.0)", "rgba(203, 243, 203, 0)", +"hsl(150 62.5% 87.5% / 0.0)", "rgba(203, 243, 223, 0)", +"hsl(180 62.5% 87.5% / 0.0)", "rgba(203, 243, 243, 0)", +"hsl(210 62.5% 87.5% / 0.0)", "rgba(203, 223, 243, 0)", +"hsl(240 62.5% 87.5% / 0.0)", "rgba(203, 203, 243, 0)", +"hsl(270 62.5% 87.5% / 0.0)", "rgba(223, 203, 243, 0)", +"hsl(300 62.5% 87.5% / 0.0)", "rgba(243, 203, 243, 0)", +"hsl(330 62.5% 87.5% / 0.0)", "rgba(243, 203, 223, 0)", +"hsl(0 75% 87.5% / 0.0)", "rgba(247, 199, 199, 0)", +"hsl(30 75% 87.5% / 0.0)", "rgba(247, 223, 199, 0)", +"hsl(60 75% 87.5% / 0.0)", "rgba(247, 247, 199, 0)", +"hsl(90 75% 87.5% / 0.0)", "rgba(223, 247, 199, 0)", +"hsl(120 75% 87.5% / 0.0)", "rgba(199, 247, 199, 0)", +"hsl(150 75% 87.5% / 0.0)", "rgba(199, 247, 223, 0)", +"hsl(180 75% 87.5% / 0.0)", "rgba(199, 247, 247, 0)", +"hsl(210 75% 87.5% / 0.0)", "rgba(199, 223, 247, 0)", +"hsl(240 75% 87.5% / 0.0)", "rgba(199, 199, 247, 0)", +"hsl(270 75% 87.5% / 0.0)", "rgba(223, 199, 247, 0)", +"hsl(300 75% 87.5% / 0.0)", "rgba(247, 199, 247, 0)", +"hsl(330 75% 87.5% / 0.0)", "rgba(247, 199, 223, 0)", +"hsl(0 87.5% 87.5% / 0.0)", "rgba(251, 195, 195, 0)", +"hsl(30 87.5% 87.5% / 0.0)", "rgba(251, 223, 195, 0)", +"hsl(60 87.5% 87.5% / 0.0)", "rgba(251, 251, 195, 0)", +"hsl(90 87.5% 87.5% / 0.0)", "rgba(223, 251, 195, 0)", +"hsl(120 87.5% 87.5% / 0.0)", "rgba(195, 251, 195, 0)", +"hsl(150 87.5% 87.5% / 0.0)", "rgba(195, 251, 223, 0)", +"hsl(180 87.5% 87.5% / 0.0)", "rgba(195, 251, 251, 0)", +"hsl(210 87.5% 87.5% / 0.0)", "rgba(195, 223, 251, 0)", +"hsl(240 87.5% 87.5% / 0.0)", "rgba(195, 195, 251, 0)", +"hsl(270 87.5% 87.5% / 0.0)", "rgba(223, 195, 251, 0)", +"hsl(300 87.5% 87.5% / 0.0)", "rgba(251, 195, 251, 0)", +"hsl(330 87.5% 87.5% / 0.0)", "rgba(251, 195, 223, 0)", +"hsl(0 100% 87.5% / 0.0)", "rgba(255, 191, 191, 0)", +"hsl(30 100% 87.5% / 0.0)", "rgba(255, 223, 191, 0)", +"hsl(60 100% 87.5% / 0.0)", "rgba(255, 255, 191, 0)", +"hsl(90 100% 87.5% / 0.0)", "rgba(223, 255, 191, 0)", +"hsl(120 100% 87.5% / 0.0)", "rgba(191, 255, 191, 0)", +"hsl(150 100% 87.5% / 0.0)", "rgba(191, 255, 223, 0)", +"hsl(180 100% 87.5% / 0.0)", "rgba(191, 255, 255, 0)", +"hsl(210 100% 87.5% / 0.0)", "rgba(191, 223, 255, 0)", +"hsl(240 100% 87.5% / 0.0)", "rgba(191, 191, 255, 0)", +"hsl(270 100% 87.5% / 0.0)", "rgba(223, 191, 255, 0)", +"hsl(300 100% 87.5% / 0.0)", "rgba(255, 191, 255, 0)", +"hsl(330 100% 87.5% / 0.0)", "rgba(255, 191, 223, 0)", +"hsl(0 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(0 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(30 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(60 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(90 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(120 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(150 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(180 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(210 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(240 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(270 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(300 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsl(330 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 0% 0%)", "rgb(0, 0, 0)", +"hsla(30 0% 0%)", "rgb(0, 0, 0)", +"hsla(60 0% 0%)", "rgb(0, 0, 0)", +"hsla(90 0% 0%)", "rgb(0, 0, 0)", +"hsla(120 0% 0%)", "rgb(0, 0, 0)", +"hsla(150 0% 0%)", "rgb(0, 0, 0)", +"hsla(180 0% 0%)", "rgb(0, 0, 0)", +"hsla(210 0% 0%)", "rgb(0, 0, 0)", +"hsla(240 0% 0%)", "rgb(0, 0, 0)", +"hsla(270 0% 0%)", "rgb(0, 0, 0)", +"hsla(300 0% 0%)", "rgb(0, 0, 0)", +"hsla(330 0% 0%)", "rgb(0, 0, 0)", +"hsla(0 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(30 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(60 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(90 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(120 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(150 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(180 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(210 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(240 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(270 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(300 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(330 12.5% 0%)", "rgb(0, 0, 0)", +"hsla(0 25% 0%)", "rgb(0, 0, 0)", +"hsla(30 25% 0%)", "rgb(0, 0, 0)", +"hsla(60 25% 0%)", "rgb(0, 0, 0)", +"hsla(90 25% 0%)", "rgb(0, 0, 0)", +"hsla(120 25% 0%)", "rgb(0, 0, 0)", +"hsla(150 25% 0%)", "rgb(0, 0, 0)", +"hsla(180 25% 0%)", "rgb(0, 0, 0)", +"hsla(210 25% 0%)", "rgb(0, 0, 0)", +"hsla(240 25% 0%)", "rgb(0, 0, 0)", +"hsla(270 25% 0%)", "rgb(0, 0, 0)", +"hsla(300 25% 0%)", "rgb(0, 0, 0)", +"hsla(330 25% 0%)", "rgb(0, 0, 0)", +"hsla(0 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(30 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(60 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(90 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(120 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(150 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(180 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(210 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(240 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(270 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(300 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(330 37.5% 0%)", "rgb(0, 0, 0)", +"hsla(0 50% 0%)", "rgb(0, 0, 0)", +"hsla(30 50% 0%)", "rgb(0, 0, 0)", +"hsla(60 50% 0%)", "rgb(0, 0, 0)", +"hsla(90 50% 0%)", "rgb(0, 0, 0)", +"hsla(120 50% 0%)", "rgb(0, 0, 0)", +"hsla(150 50% 0%)", "rgb(0, 0, 0)", +"hsla(180 50% 0%)", "rgb(0, 0, 0)", +"hsla(210 50% 0%)", "rgb(0, 0, 0)", +"hsla(240 50% 0%)", "rgb(0, 0, 0)", +"hsla(270 50% 0%)", "rgb(0, 0, 0)", +"hsla(300 50% 0%)", "rgb(0, 0, 0)", +"hsla(330 50% 0%)", "rgb(0, 0, 0)", +"hsla(0 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(30 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(60 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(90 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(120 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(150 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(180 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(210 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(240 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(270 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(300 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(330 62.5% 0%)", "rgb(0, 0, 0)", +"hsla(0 75% 0%)", "rgb(0, 0, 0)", +"hsla(30 75% 0%)", "rgb(0, 0, 0)", +"hsla(60 75% 0%)", "rgb(0, 0, 0)", +"hsla(90 75% 0%)", "rgb(0, 0, 0)", +"hsla(120 75% 0%)", "rgb(0, 0, 0)", +"hsla(150 75% 0%)", "rgb(0, 0, 0)", +"hsla(180 75% 0%)", "rgb(0, 0, 0)", +"hsla(210 75% 0%)", "rgb(0, 0, 0)", +"hsla(240 75% 0%)", "rgb(0, 0, 0)", +"hsla(270 75% 0%)", "rgb(0, 0, 0)", +"hsla(300 75% 0%)", "rgb(0, 0, 0)", +"hsla(330 75% 0%)", "rgb(0, 0, 0)", +"hsla(0 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(30 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(60 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(90 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(120 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(150 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(180 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(210 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(240 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(270 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(300 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(330 87.5% 0%)", "rgb(0, 0, 0)", +"hsla(0 100% 0%)", "rgb(0, 0, 0)", +"hsla(30 100% 0%)", "rgb(0, 0, 0)", +"hsla(60 100% 0%)", "rgb(0, 0, 0)", +"hsla(90 100% 0%)", "rgb(0, 0, 0)", +"hsla(120 100% 0%)", "rgb(0, 0, 0)", +"hsla(150 100% 0%)", "rgb(0, 0, 0)", +"hsla(180 100% 0%)", "rgb(0, 0, 0)", +"hsla(210 100% 0%)", "rgb(0, 0, 0)", +"hsla(240 100% 0%)", "rgb(0, 0, 0)", +"hsla(270 100% 0%)", "rgb(0, 0, 0)", +"hsla(300 100% 0%)", "rgb(0, 0, 0)", +"hsla(330 100% 0%)", "rgb(0, 0, 0)", +"hsla(0 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(30 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(60 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(90 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(120 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(150 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(180 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(210 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(240 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(270 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(300 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(330 0% 12.5%)", "rgb(32, 32, 32)", +"hsla(0 12.5% 12.5%)", "rgb(36, 28, 28)", +"hsla(30 12.5% 12.5%)", "rgb(36, 32, 28)", +"hsla(60 12.5% 12.5%)", "rgb(36, 36, 28)", +"hsla(90 12.5% 12.5%)", "rgb(32, 36, 28)", +"hsla(120 12.5% 12.5%)", "rgb(28, 36, 28)", +"hsla(150 12.5% 12.5%)", "rgb(28, 36, 32)", +"hsla(180 12.5% 12.5%)", "rgb(28, 36, 36)", +"hsla(210 12.5% 12.5%)", "rgb(28, 32, 36)", +"hsla(240 12.5% 12.5%)", "rgb(28, 28, 36)", +"hsla(270 12.5% 12.5%)", "rgb(32, 28, 36)", +"hsla(300 12.5% 12.5%)", "rgb(36, 28, 36)", +"hsla(330 12.5% 12.5%)", "rgb(36, 28, 32)", +"hsla(0 25% 12.5%)", "rgb(40, 24, 24)", +"hsla(30 25% 12.5%)", "rgb(40, 32, 24)", +"hsla(60 25% 12.5%)", "rgb(40, 40, 24)", +"hsla(90 25% 12.5%)", "rgb(32, 40, 24)", +"hsla(120 25% 12.5%)", "rgb(24, 40, 24)", +"hsla(150 25% 12.5%)", "rgb(24, 40, 32)", +"hsla(180 25% 12.5%)", "rgb(24, 40, 40)", +"hsla(210 25% 12.5%)", "rgb(24, 32, 40)", +"hsla(240 25% 12.5%)", "rgb(24, 24, 40)", +"hsla(270 25% 12.5%)", "rgb(32, 24, 40)", +"hsla(300 25% 12.5%)", "rgb(40, 24, 40)", +"hsla(330 25% 12.5%)", "rgb(40, 24, 32)", +"hsla(0 37.5% 12.5%)", "rgb(44, 20, 20)", +"hsla(30 37.5% 12.5%)", "rgb(44, 32, 20)", +"hsla(60 37.5% 12.5%)", "rgb(44, 44, 20)", +"hsla(90 37.5% 12.5%)", "rgb(32, 44, 20)", +"hsla(120 37.5% 12.5%)", "rgb(20, 44, 20)", +"hsla(150 37.5% 12.5%)", "rgb(20, 44, 32)", +"hsla(180 37.5% 12.5%)", "rgb(20, 44, 44)", +"hsla(210 37.5% 12.5%)", "rgb(20, 32, 44)", +"hsla(240 37.5% 12.5%)", "rgb(20, 20, 44)", +"hsla(270 37.5% 12.5%)", "rgb(32, 20, 44)", +"hsla(300 37.5% 12.5%)", "rgb(44, 20, 44)", +"hsla(330 37.5% 12.5%)", "rgb(44, 20, 32)", +"hsla(0 50% 12.5%)", "rgb(48, 16, 16)", +"hsla(30 50% 12.5%)", "rgb(48, 32, 16)", +"hsla(60 50% 12.5%)", "rgb(48, 48, 16)", +"hsla(90 50% 12.5%)", "rgb(32, 48, 16)", +"hsla(120 50% 12.5%)", "rgb(16, 48, 16)", +"hsla(150 50% 12.5%)", "rgb(16, 48, 32)", +"hsla(180 50% 12.5%)", "rgb(16, 48, 48)", +"hsla(210 50% 12.5%)", "rgb(16, 32, 48)", +"hsla(240 50% 12.5%)", "rgb(16, 16, 48)", +"hsla(270 50% 12.5%)", "rgb(32, 16, 48)", +"hsla(300 50% 12.5%)", "rgb(48, 16, 48)", +"hsla(330 50% 12.5%)", "rgb(48, 16, 32)", +"hsla(0 62.5% 12.5%)", "rgb(52, 12, 12)", +"hsla(30 62.5% 12.5%)", "rgb(52, 32, 12)", +"hsla(60 62.5% 12.5%)", "rgb(52, 52, 12)", +"hsla(90 62.5% 12.5%)", "rgb(32, 52, 12)", +"hsla(120 62.5% 12.5%)", "rgb(12, 52, 12)", +"hsla(150 62.5% 12.5%)", "rgb(12, 52, 32)", +"hsla(180 62.5% 12.5%)", "rgb(12, 52, 52)", +"hsla(210 62.5% 12.5%)", "rgb(12, 32, 52)", +"hsla(240 62.5% 12.5%)", "rgb(12, 12, 52)", +"hsla(270 62.5% 12.5%)", "rgb(32, 12, 52)", +"hsla(300 62.5% 12.5%)", "rgb(52, 12, 52)", +"hsla(330 62.5% 12.5%)", "rgb(52, 12, 32)", +"hsla(0 75% 12.5%)", "rgb(56, 8, 8)", +"hsla(30 75% 12.5%)", "rgb(56, 32, 8)", +"hsla(60 75% 12.5%)", "rgb(56, 56, 8)", +"hsla(90 75% 12.5%)", "rgb(32, 56, 8)", +"hsla(120 75% 12.5%)", "rgb(8, 56, 8)", +"hsla(150 75% 12.5%)", "rgb(8, 56, 32)", +"hsla(180 75% 12.5%)", "rgb(8, 56, 56)", +"hsla(210 75% 12.5%)", "rgb(8, 32, 56)", +"hsla(240 75% 12.5%)", "rgb(8, 8, 56)", +"hsla(270 75% 12.5%)", "rgb(32, 8, 56)", +"hsla(300 75% 12.5%)", "rgb(56, 8, 56)", +"hsla(330 75% 12.5%)", "rgb(56, 8, 32)", +"hsla(0 87.5% 12.5%)", "rgb(60, 4, 4)", +"hsla(30 87.5% 12.5%)", "rgb(60, 32, 4)", +"hsla(60 87.5% 12.5%)", "rgb(60, 60, 4)", +"hsla(90 87.5% 12.5%)", "rgb(32, 60, 4)", +"hsla(120 87.5% 12.5%)", "rgb(4, 60, 4)", +"hsla(150 87.5% 12.5%)", "rgb(4, 60, 32)", +"hsla(180 87.5% 12.5%)", "rgb(4, 60, 60)", +"hsla(210 87.5% 12.5%)", "rgb(4, 32, 60)", +"hsla(240 87.5% 12.5%)", "rgb(4, 4, 60)", +"hsla(270 87.5% 12.5%)", "rgb(32, 4, 60)", +"hsla(300 87.5% 12.5%)", "rgb(60, 4, 60)", +"hsla(330 87.5% 12.5%)", "rgb(60, 4, 32)", +"hsla(0 100% 12.5%)", "rgb(64, 0, 0)", +"hsla(30 100% 12.5%)", "rgb(64, 32, 0)", +"hsla(60 100% 12.5%)", "rgb(64, 64, 0)", +"hsla(90 100% 12.5%)", "rgb(32, 64, 0)", +"hsla(120 100% 12.5%)", "rgb(0, 64, 0)", +"hsla(150 100% 12.5%)", "rgb(0, 64, 32)", +"hsla(180 100% 12.5%)", "rgb(0, 64, 64)", +"hsla(210 100% 12.5%)", "rgb(0, 32, 64)", +"hsla(240 100% 12.5%)", "rgb(0, 0, 64)", +"hsla(270 100% 12.5%)", "rgb(32, 0, 64)", +"hsla(300 100% 12.5%)", "rgb(64, 0, 64)", +"hsla(330 100% 12.5%)", "rgb(64, 0, 32)", +"hsla(0 0% 25%)", "rgb(64, 64, 64)", +"hsla(30 0% 25%)", "rgb(64, 64, 64)", +"hsla(60 0% 25%)", "rgb(64, 64, 64)", +"hsla(90 0% 25%)", "rgb(64, 64, 64)", +"hsla(120 0% 25%)", "rgb(64, 64, 64)", +"hsla(150 0% 25%)", "rgb(64, 64, 64)", +"hsla(180 0% 25%)", "rgb(64, 64, 64)", +"hsla(210 0% 25%)", "rgb(64, 64, 64)", +"hsla(240 0% 25%)", "rgb(64, 64, 64)", +"hsla(270 0% 25%)", "rgb(64, 64, 64)", +"hsla(300 0% 25%)", "rgb(64, 64, 64)", +"hsla(330 0% 25%)", "rgb(64, 64, 64)", +"hsla(0 12.5% 25%)", "rgb(72, 56, 56)", +"hsla(30 12.5% 25%)", "rgb(72, 64, 56)", +"hsla(60 12.5% 25%)", "rgb(72, 72, 56)", +"hsla(90 12.5% 25%)", "rgb(64, 72, 56)", +"hsla(120 12.5% 25%)", "rgb(56, 72, 56)", +"hsla(150 12.5% 25%)", "rgb(56, 72, 64)", +"hsla(180 12.5% 25%)", "rgb(56, 72, 72)", +"hsla(210 12.5% 25%)", "rgb(56, 64, 72)", +"hsla(240 12.5% 25%)", "rgb(56, 56, 72)", +"hsla(270 12.5% 25%)", "rgb(64, 56, 72)", +"hsla(300 12.5% 25%)", "rgb(72, 56, 72)", +"hsla(330 12.5% 25%)", "rgb(72, 56, 64)", +"hsla(0 25% 25%)", "rgb(80, 48, 48)", +"hsla(30 25% 25%)", "rgb(80, 64, 48)", +"hsla(60 25% 25%)", "rgb(80, 80, 48)", +"hsla(90 25% 25%)", "rgb(64, 80, 48)", +"hsla(120 25% 25%)", "rgb(48, 80, 48)", +"hsla(150 25% 25%)", "rgb(48, 80, 64)", +"hsla(180 25% 25%)", "rgb(48, 80, 80)", +"hsla(210 25% 25%)", "rgb(48, 64, 80)", +"hsla(240 25% 25%)", "rgb(48, 48, 80)", +"hsla(270 25% 25%)", "rgb(64, 48, 80)", +"hsla(300 25% 25%)", "rgb(80, 48, 80)", +"hsla(330 25% 25%)", "rgb(80, 48, 64)", +"hsla(0 37.5% 25%)", "rgb(88, 40, 40)", +"hsla(30 37.5% 25%)", "rgb(88, 64, 40)", +"hsla(60 37.5% 25%)", "rgb(88, 88, 40)", +"hsla(90 37.5% 25%)", "rgb(64, 88, 40)", +"hsla(120 37.5% 25%)", "rgb(40, 88, 40)", +"hsla(150 37.5% 25%)", "rgb(40, 88, 64)", +"hsla(180 37.5% 25%)", "rgb(40, 88, 88)", +"hsla(210 37.5% 25%)", "rgb(40, 64, 88)", +"hsla(240 37.5% 25%)", "rgb(40, 40, 88)", +"hsla(270 37.5% 25%)", "rgb(64, 40, 88)", +"hsla(300 37.5% 25%)", "rgb(88, 40, 88)", +"hsla(330 37.5% 25%)", "rgb(88, 40, 64)", +"hsla(0 50% 25%)", "rgb(96, 32, 32)", +"hsla(30 50% 25%)", "rgb(96, 64, 32)", +"hsla(60 50% 25%)", "rgb(96, 96, 32)", +"hsla(90 50% 25%)", "rgb(64, 96, 32)", +"hsla(120 50% 25%)", "rgb(32, 96, 32)", +"hsla(150 50% 25%)", "rgb(32, 96, 64)", +"hsla(180 50% 25%)", "rgb(32, 96, 96)", +"hsla(210 50% 25%)", "rgb(32, 64, 96)", +"hsla(240 50% 25%)", "rgb(32, 32, 96)", +"hsla(270 50% 25%)", "rgb(64, 32, 96)", +"hsla(300 50% 25%)", "rgb(96, 32, 96)", +"hsla(330 50% 25%)", "rgb(96, 32, 64)", +"hsla(0 62.5% 25%)", "rgb(104, 24, 24)", +"hsla(30 62.5% 25%)", "rgb(104, 64, 24)", +"hsla(60 62.5% 25%)", "rgb(104, 104, 24)", +"hsla(90 62.5% 25%)", "rgb(64, 104, 24)", +"hsla(120 62.5% 25%)", "rgb(24, 104, 24)", +"hsla(150 62.5% 25%)", "rgb(24, 104, 64)", +"hsla(180 62.5% 25%)", "rgb(24, 104, 104)", +"hsla(210 62.5% 25%)", "rgb(24, 64, 104)", +"hsla(240 62.5% 25%)", "rgb(24, 24, 104)", +"hsla(270 62.5% 25%)", "rgb(64, 24, 104)", +"hsla(300 62.5% 25%)", "rgb(104, 24, 104)", +"hsla(330 62.5% 25%)", "rgb(104, 24, 64)", +"hsla(0 75% 25%)", "rgb(112, 16, 16)", +"hsla(30 75% 25%)", "rgb(112, 64, 16)", +"hsla(60 75% 25%)", "rgb(112, 112, 16)", +"hsla(90 75% 25%)", "rgb(64, 112, 16)", +"hsla(120 75% 25%)", "rgb(16, 112, 16)", +"hsla(150 75% 25%)", "rgb(16, 112, 64)", +"hsla(180 75% 25%)", "rgb(16, 112, 112)", +"hsla(210 75% 25%)", "rgb(16, 64, 112)", +"hsla(240 75% 25%)", "rgb(16, 16, 112)", +"hsla(270 75% 25%)", "rgb(64, 16, 112)", +"hsla(300 75% 25%)", "rgb(112, 16, 112)", +"hsla(330 75% 25%)", "rgb(112, 16, 64)", +"hsla(0 87.5% 25%)", "rgb(120, 8, 8)", +"hsla(30 87.5% 25%)", "rgb(120, 64, 8)", +"hsla(60 87.5% 25%)", "rgb(120, 120, 8)", +"hsla(90 87.5% 25%)", "rgb(64, 120, 8)", +"hsla(120 87.5% 25%)", "rgb(8, 120, 8)", +"hsla(150 87.5% 25%)", "rgb(8, 120, 64)", +"hsla(180 87.5% 25%)", "rgb(8, 120, 120)", +"hsla(210 87.5% 25%)", "rgb(8, 64, 120)", +"hsla(240 87.5% 25%)", "rgb(8, 8, 120)", +"hsla(270 87.5% 25%)", "rgb(64, 8, 120)", +"hsla(300 87.5% 25%)", "rgb(120, 8, 120)", +"hsla(330 87.5% 25%)", "rgb(120, 8, 64)", +"hsla(0 100% 25%)", "rgb(128, 0, 0)", +"hsla(30 100% 25%)", "rgb(128, 64, 0)", +"hsla(60 100% 25%)", "rgb(128, 128, 0)", +"hsla(90 100% 25%)", "rgb(64, 128, 0)", +"hsla(120 100% 25%)", "rgb(0, 128, 0)", +"hsla(150 100% 25%)", "rgb(0, 128, 64)", +"hsla(180 100% 25%)", "rgb(0, 128, 128)", +"hsla(210 100% 25%)", "rgb(0, 64, 128)", +"hsla(240 100% 25%)", "rgb(0, 0, 128)", +"hsla(270 100% 25%)", "rgb(64, 0, 128)", +"hsla(300 100% 25%)", "rgb(128, 0, 128)", +"hsla(330 100% 25%)", "rgb(128, 0, 64)", +"hsla(0 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(30 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(60 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(90 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(120 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(150 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(180 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(210 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(240 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(270 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(300 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(330 0% 37.5%)", "rgb(96, 96, 96)", +"hsla(0 12.5% 37.5%)", "rgb(108, 84, 84)", +"hsla(30 12.5% 37.5%)", "rgb(108, 96, 84)", +"hsla(60 12.5% 37.5%)", "rgb(108, 108, 84)", +"hsla(90 12.5% 37.5%)", "rgb(96, 108, 84)", +"hsla(120 12.5% 37.5%)", "rgb(84, 108, 84)", +"hsla(150 12.5% 37.5%)", "rgb(84, 108, 96)", +"hsla(180 12.5% 37.5%)", "rgb(84, 108, 108)", +"hsla(210 12.5% 37.5%)", "rgb(84, 96, 108)", +"hsla(240 12.5% 37.5%)", "rgb(84, 84, 108)", +"hsla(270 12.5% 37.5%)", "rgb(96, 84, 108)", +"hsla(300 12.5% 37.5%)", "rgb(108, 84, 108)", +"hsla(330 12.5% 37.5%)", "rgb(108, 84, 96)", +"hsla(0 25% 37.5%)", "rgb(120, 72, 72)", +"hsla(30 25% 37.5%)", "rgb(120, 96, 72)", +"hsla(60 25% 37.5%)", "rgb(120, 120, 72)", +"hsla(90 25% 37.5%)", "rgb(96, 120, 72)", +"hsla(120 25% 37.5%)", "rgb(72, 120, 72)", +"hsla(150 25% 37.5%)", "rgb(72, 120, 96)", +"hsla(180 25% 37.5%)", "rgb(72, 120, 120)", +"hsla(210 25% 37.5%)", "rgb(72, 96, 120)", +"hsla(240 25% 37.5%)", "rgb(72, 72, 120)", +"hsla(270 25% 37.5%)", "rgb(96, 72, 120)", +"hsla(300 25% 37.5%)", "rgb(120, 72, 120)", +"hsla(330 25% 37.5%)", "rgb(120, 72, 96)", +"hsla(0 37.5% 37.5%)", "rgb(131, 60, 60)", +"hsla(30 37.5% 37.5%)", "rgb(131, 96, 60)", +"hsla(60 37.5% 37.5%)", "rgb(131, 131, 60)", +"hsla(90 37.5% 37.5%)", "rgb(96, 131, 60)", +"hsla(120 37.5% 37.5%)", "rgb(60, 131, 60)", +"hsla(150 37.5% 37.5%)", "rgb(60, 131, 96)", +"hsla(180 37.5% 37.5%)", "rgb(60, 131, 131)", +"hsla(210 37.5% 37.5%)", "rgb(60, 96, 131)", +"hsla(240 37.5% 37.5%)", "rgb(60, 60, 131)", +"hsla(270 37.5% 37.5%)", "rgb(96, 60, 131)", +"hsla(300 37.5% 37.5%)", "rgb(131, 60, 131)", +"hsla(330 37.5% 37.5%)", "rgb(131, 60, 96)", +"hsla(0 50% 37.5%)", "rgb(143, 48, 48)", +"hsla(30 50% 37.5%)", "rgb(143, 96, 48)", +"hsla(60 50% 37.5%)", "rgb(143, 143, 48)", +"hsla(90 50% 37.5%)", "rgb(96, 143, 48)", +"hsla(120 50% 37.5%)", "rgb(48, 143, 48)", +"hsla(150 50% 37.5%)", "rgb(48, 143, 96)", +"hsla(180 50% 37.5%)", "rgb(48, 143, 143)", +"hsla(210 50% 37.5%)", "rgb(48, 96, 143)", +"hsla(240 50% 37.5%)", "rgb(48, 48, 143)", +"hsla(270 50% 37.5%)", "rgb(96, 48, 143)", +"hsla(300 50% 37.5%)", "rgb(143, 48, 143)", +"hsla(330 50% 37.5%)", "rgb(143, 48, 96)", +"hsla(0 62.5% 37.5%)", "rgb(155, 36, 36)", +"hsla(30 62.5% 37.5%)", "rgb(155, 96, 36)", +"hsla(60 62.5% 37.5%)", "rgb(155, 155, 36)", +"hsla(90 62.5% 37.5%)", "rgb(96, 155, 36)", +"hsla(120 62.5% 37.5%)", "rgb(36, 155, 36)", +"hsla(150 62.5% 37.5%)", "rgb(36, 155, 96)", +"hsla(180 62.5% 37.5%)", "rgb(36, 155, 155)", +"hsla(210 62.5% 37.5%)", "rgb(36, 96, 155)", +"hsla(240 62.5% 37.5%)", "rgb(36, 36, 155)", +"hsla(270 62.5% 37.5%)", "rgb(96, 36, 155)", +"hsla(300 62.5% 37.5%)", "rgb(155, 36, 155)", +"hsla(330 62.5% 37.5%)", "rgb(155, 36, 96)", +"hsla(0 75% 37.5%)", "rgb(167, 24, 24)", +"hsla(30 75% 37.5%)", "rgb(167, 96, 24)", +"hsla(60 75% 37.5%)", "rgb(167, 167, 24)", +"hsla(90 75% 37.5%)", "rgb(96, 167, 24)", +"hsla(120 75% 37.5%)", "rgb(24, 167, 24)", +"hsla(150 75% 37.5%)", "rgb(24, 167, 96)", +"hsla(180 75% 37.5%)", "rgb(24, 167, 167)", +"hsla(210 75% 37.5%)", "rgb(24, 96, 167)", +"hsla(240 75% 37.5%)", "rgb(24, 24, 167)", +"hsla(270 75% 37.5%)", "rgb(96, 24, 167)", +"hsla(300 75% 37.5%)", "rgb(167, 24, 167)", +"hsla(330 75% 37.5%)", "rgb(167, 24, 96)", +"hsla(0 87.5% 37.5%)", "rgb(179, 12, 12)", +"hsla(30 87.5% 37.5%)", "rgb(179, 96, 12)", +"hsla(60 87.5% 37.5%)", "rgb(179, 179, 12)", +"hsla(90 87.5% 37.5%)", "rgb(96, 179, 12)", +"hsla(120 87.5% 37.5%)", "rgb(12, 179, 12)", +"hsla(150 87.5% 37.5%)", "rgb(12, 179, 96)", +"hsla(180 87.5% 37.5%)", "rgb(12, 179, 179)", +"hsla(210 87.5% 37.5%)", "rgb(12, 96, 179)", +"hsla(240 87.5% 37.5%)", "rgb(12, 12, 179)", +"hsla(270 87.5% 37.5%)", "rgb(96, 12, 179)", +"hsla(300 87.5% 37.5%)", "rgb(179, 12, 179)", +"hsla(330 87.5% 37.5%)", "rgb(179, 12, 96)", +"hsla(0 100% 37.5%)", "rgb(191, 0, 0)", +"hsla(30 100% 37.5%)", "rgb(191, 96, 0)", +"hsla(60 100% 37.5%)", "rgb(191, 191, 0)", +"hsla(90 100% 37.5%)", "rgb(96, 191, 0)", +"hsla(120 100% 37.5%)", "rgb(0, 191, 0)", +"hsla(150 100% 37.5%)", "rgb(0, 191, 96)", +"hsla(180 100% 37.5%)", "rgb(0, 191, 191)", +"hsla(210 100% 37.5%)", "rgb(0, 96, 191)", +"hsla(240 100% 37.5%)", "rgb(0, 0, 191)", +"hsla(270 100% 37.5%)", "rgb(96, 0, 191)", +"hsla(300 100% 37.5%)", "rgb(191, 0, 191)", +"hsla(330 100% 37.5%)", "rgb(191, 0, 96)", +"hsla(0 0% 50%)", "rgb(128, 128, 128)", +"hsla(30 0% 50%)", "rgb(128, 128, 128)", +"hsla(60 0% 50%)", "rgb(128, 128, 128)", +"hsla(90 0% 50%)", "rgb(128, 128, 128)", +"hsla(120 0% 50%)", "rgb(128, 128, 128)", +"hsla(150 0% 50%)", "rgb(128, 128, 128)", +"hsla(180 0% 50%)", "rgb(128, 128, 128)", +"hsla(210 0% 50%)", "rgb(128, 128, 128)", +"hsla(240 0% 50%)", "rgb(128, 128, 128)", +"hsla(270 0% 50%)", "rgb(128, 128, 128)", +"hsla(300 0% 50%)", "rgb(128, 128, 128)", +"hsla(330 0% 50%)", "rgb(128, 128, 128)", +"hsla(0 12.5% 50%)", "rgb(143, 112, 112)", +"hsla(30 12.5% 50%)", "rgb(143, 128, 112)", +"hsla(60 12.5% 50%)", "rgb(143, 143, 112)", +"hsla(90 12.5% 50%)", "rgb(128, 143, 112)", +"hsla(120 12.5% 50%)", "rgb(112, 143, 112)", +"hsla(150 12.5% 50%)", "rgb(112, 143, 128)", +"hsla(180 12.5% 50%)", "rgb(112, 143, 143)", +"hsla(210 12.5% 50%)", "rgb(112, 128, 143)", +"hsla(240 12.5% 50%)", "rgb(112, 112, 143)", +"hsla(270 12.5% 50%)", "rgb(128, 112, 143)", +"hsla(300 12.5% 50%)", "rgb(143, 112, 143)", +"hsla(330 12.5% 50%)", "rgb(143, 112, 128)", +"hsla(0 25% 50%)", "rgb(159, 96, 96)", +"hsla(30 25% 50%)", "rgb(159, 128, 96)", +"hsla(60 25% 50%)", "rgb(159, 159, 96)", +"hsla(90 25% 50%)", "rgb(128, 159, 96)", +"hsla(120 25% 50%)", "rgb(96, 159, 96)", +"hsla(150 25% 50%)", "rgb(96, 159, 128)", +"hsla(180 25% 50%)", "rgb(96, 159, 159)", +"hsla(210 25% 50%)", "rgb(96, 128, 159)", +"hsla(240 25% 50%)", "rgb(96, 96, 159)", +"hsla(270 25% 50%)", "rgb(128, 96, 159)", +"hsla(300 25% 50%)", "rgb(159, 96, 159)", +"hsla(330 25% 50%)", "rgb(159, 96, 128)", +"hsla(0 37.5% 50%)", "rgb(175, 80, 80)", +"hsla(30 37.5% 50%)", "rgb(175, 128, 80)", +"hsla(60 37.5% 50%)", "rgb(175, 175, 80)", +"hsla(90 37.5% 50%)", "rgb(128, 175, 80)", +"hsla(120 37.5% 50%)", "rgb(80, 175, 80)", +"hsla(150 37.5% 50%)", "rgb(80, 175, 128)", +"hsla(180 37.5% 50%)", "rgb(80, 175, 175)", +"hsla(210 37.5% 50%)", "rgb(80, 128, 175)", +"hsla(240 37.5% 50%)", "rgb(80, 80, 175)", +"hsla(270 37.5% 50%)", "rgb(128, 80, 175)", +"hsla(300 37.5% 50%)", "rgb(175, 80, 175)", +"hsla(330 37.5% 50%)", "rgb(175, 80, 128)", +"hsla(0 50% 50%)", "rgb(191, 64, 64)", +"hsla(30 50% 50%)", "rgb(191, 128, 64)", +"hsla(60 50% 50%)", "rgb(191, 191, 64)", +"hsla(90 50% 50%)", "rgb(128, 191, 64)", +"hsla(120 50% 50%)", "rgb(64, 191, 64)", +"hsla(150 50% 50%)", "rgb(64, 191, 128)", +"hsla(180 50% 50%)", "rgb(64, 191, 191)", +"hsla(210 50% 50%)", "rgb(64, 128, 191)", +"hsla(240 50% 50%)", "rgb(64, 64, 191)", +"hsla(270 50% 50%)", "rgb(128, 64, 191)", +"hsla(300 50% 50%)", "rgb(191, 64, 191)", +"hsla(330 50% 50%)", "rgb(191, 64, 128)", +"hsla(0 62.5% 50%)", "rgb(207, 48, 48)", +"hsla(30 62.5% 50%)", "rgb(207, 128, 48)", +"hsla(60 62.5% 50%)", "rgb(207, 207, 48)", +"hsla(90 62.5% 50%)", "rgb(128, 207, 48)", +"hsla(120 62.5% 50%)", "rgb(48, 207, 48)", +"hsla(150 62.5% 50%)", "rgb(48, 207, 128)", +"hsla(180 62.5% 50%)", "rgb(48, 207, 207)", +"hsla(210 62.5% 50%)", "rgb(48, 128, 207)", +"hsla(240 62.5% 50%)", "rgb(48, 48, 207)", +"hsla(270 62.5% 50%)", "rgb(128, 48, 207)", +"hsla(300 62.5% 50%)", "rgb(207, 48, 207)", +"hsla(330 62.5% 50%)", "rgb(207, 48, 128)", +"hsla(0 75% 50%)", "rgb(223, 32, 32)", +"hsla(30 75% 50%)", "rgb(223, 128, 32)", +"hsla(60 75% 50%)", "rgb(223, 223, 32)", +"hsla(90 75% 50%)", "rgb(128, 223, 32)", +"hsla(120 75% 50%)", "rgb(32, 223, 32)", +"hsla(150 75% 50%)", "rgb(32, 223, 128)", +"hsla(180 75% 50%)", "rgb(32, 223, 223)", +"hsla(210 75% 50%)", "rgb(32, 128, 223)", +"hsla(240 75% 50%)", "rgb(32, 32, 223)", +"hsla(270 75% 50%)", "rgb(128, 32, 223)", +"hsla(300 75% 50%)", "rgb(223, 32, 223)", +"hsla(330 75% 50%)", "rgb(223, 32, 128)", +"hsla(0 87.5% 50%)", "rgb(239, 16, 16)", +"hsla(30 87.5% 50%)", "rgb(239, 128, 16)", +"hsla(60 87.5% 50%)", "rgb(239, 239, 16)", +"hsla(90 87.5% 50%)", "rgb(128, 239, 16)", +"hsla(120 87.5% 50%)", "rgb(16, 239, 16)", +"hsla(150 87.5% 50%)", "rgb(16, 239, 128)", +"hsla(180 87.5% 50%)", "rgb(16, 239, 239)", +"hsla(210 87.5% 50%)", "rgb(16, 128, 239)", +"hsla(240 87.5% 50%)", "rgb(16, 16, 239)", +"hsla(270 87.5% 50%)", "rgb(128, 16, 239)", +"hsla(300 87.5% 50%)", "rgb(239, 16, 239)", +"hsla(330 87.5% 50%)", "rgb(239, 16, 128)", +"hsla(0 100% 50%)", "rgb(255, 0, 0)", +"hsla(30 100% 50%)", "rgb(255, 128, 0)", +"hsla(60 100% 50%)", "rgb(255, 255, 0)", +"hsla(90 100% 50%)", "rgb(128, 255, 0)", +"hsla(120 100% 50%)", "rgb(0, 255, 0)", +"hsla(150 100% 50%)", "rgb(0, 255, 128)", +"hsla(180 100% 50%)", "rgb(0, 255, 255)", +"hsla(210 100% 50%)", "rgb(0, 128, 255)", +"hsla(240 100% 50%)", "rgb(0, 0, 255)", +"hsla(270 100% 50%)", "rgb(128, 0, 255)", +"hsla(300 100% 50%)", "rgb(255, 0, 255)", +"hsla(330 100% 50%)", "rgb(255, 0, 128)", +"hsla(0 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(30 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(60 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(90 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(120 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(150 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(180 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(210 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(240 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(270 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(300 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(330 0% 62.5%)", "rgb(159, 159, 159)", +"hsla(0 12.5% 62.5%)", "rgb(171, 147, 147)", +"hsla(30 12.5% 62.5%)", "rgb(171, 159, 147)", +"hsla(60 12.5% 62.5%)", "rgb(171, 171, 147)", +"hsla(90 12.5% 62.5%)", "rgb(159, 171, 147)", +"hsla(120 12.5% 62.5%)", "rgb(147, 171, 147)", +"hsla(150 12.5% 62.5%)", "rgb(147, 171, 159)", +"hsla(180 12.5% 62.5%)", "rgb(147, 171, 171)", +"hsla(210 12.5% 62.5%)", "rgb(147, 159, 171)", +"hsla(240 12.5% 62.5%)", "rgb(147, 147, 171)", +"hsla(270 12.5% 62.5%)", "rgb(159, 147, 171)", +"hsla(300 12.5% 62.5%)", "rgb(171, 147, 171)", +"hsla(330 12.5% 62.5%)", "rgb(171, 147, 159)", +"hsla(0 25% 62.5%)", "rgb(183, 135, 135)", +"hsla(30 25% 62.5%)", "rgb(183, 159, 135)", +"hsla(60 25% 62.5%)", "rgb(183, 183, 135)", +"hsla(90 25% 62.5%)", "rgb(159, 183, 135)", +"hsla(120 25% 62.5%)", "rgb(135, 183, 135)", +"hsla(150 25% 62.5%)", "rgb(135, 183, 159)", +"hsla(180 25% 62.5%)", "rgb(135, 183, 183)", +"hsla(210 25% 62.5%)", "rgb(135, 159, 183)", +"hsla(240 25% 62.5%)", "rgb(135, 135, 183)", +"hsla(270 25% 62.5%)", "rgb(159, 135, 183)", +"hsla(300 25% 62.5%)", "rgb(183, 135, 183)", +"hsla(330 25% 62.5%)", "rgb(183, 135, 159)", +"hsla(0 37.5% 62.5%)", "rgb(195, 124, 124)", +"hsla(30 37.5% 62.5%)", "rgb(195, 159, 124)", +"hsla(60 37.5% 62.5%)", "rgb(195, 195, 124)", +"hsla(90 37.5% 62.5%)", "rgb(159, 195, 124)", +"hsla(120 37.5% 62.5%)", "rgb(124, 195, 124)", +"hsla(150 37.5% 62.5%)", "rgb(124, 195, 159)", +"hsla(180 37.5% 62.5%)", "rgb(124, 195, 195)", +"hsla(210 37.5% 62.5%)", "rgb(124, 159, 195)", +"hsla(240 37.5% 62.5%)", "rgb(124, 124, 195)", +"hsla(270 37.5% 62.5%)", "rgb(159, 124, 195)", +"hsla(300 37.5% 62.5%)", "rgb(195, 124, 195)", +"hsla(330 37.5% 62.5%)", "rgb(195, 124, 159)", +"hsla(0 50% 62.5%)", "rgb(207, 112, 112)", +"hsla(30 50% 62.5%)", "rgb(207, 159, 112)", +"hsla(60 50% 62.5%)", "rgb(207, 207, 112)", +"hsla(90 50% 62.5%)", "rgb(159, 207, 112)", +"hsla(120 50% 62.5%)", "rgb(112, 207, 112)", +"hsla(150 50% 62.5%)", "rgb(112, 207, 159)", +"hsla(180 50% 62.5%)", "rgb(112, 207, 207)", +"hsla(210 50% 62.5%)", "rgb(112, 159, 207)", +"hsla(240 50% 62.5%)", "rgb(112, 112, 207)", +"hsla(270 50% 62.5%)", "rgb(159, 112, 207)", +"hsla(300 50% 62.5%)", "rgb(207, 112, 207)", +"hsla(330 50% 62.5%)", "rgb(207, 112, 159)", +"hsla(0 62.5% 62.5%)", "rgb(219, 100, 100)", +"hsla(30 62.5% 62.5%)", "rgb(219, 159, 100)", +"hsla(60 62.5% 62.5%)", "rgb(219, 219, 100)", +"hsla(90 62.5% 62.5%)", "rgb(159, 219, 100)", +"hsla(120 62.5% 62.5%)", "rgb(100, 219, 100)", +"hsla(150 62.5% 62.5%)", "rgb(100, 219, 159)", +"hsla(180 62.5% 62.5%)", "rgb(100, 219, 219)", +"hsla(210 62.5% 62.5%)", "rgb(100, 159, 219)", +"hsla(240 62.5% 62.5%)", "rgb(100, 100, 219)", +"hsla(270 62.5% 62.5%)", "rgb(159, 100, 219)", +"hsla(300 62.5% 62.5%)", "rgb(219, 100, 219)", +"hsla(330 62.5% 62.5%)", "rgb(219, 100, 159)", +"hsla(0 75% 62.5%)", "rgb(231, 88, 88)", +"hsla(30 75% 62.5%)", "rgb(231, 159, 88)", +"hsla(60 75% 62.5%)", "rgb(231, 231, 88)", +"hsla(90 75% 62.5%)", "rgb(159, 231, 88)", +"hsla(120 75% 62.5%)", "rgb(88, 231, 88)", +"hsla(150 75% 62.5%)", "rgb(88, 231, 159)", +"hsla(180 75% 62.5%)", "rgb(88, 231, 231)", +"hsla(210 75% 62.5%)", "rgb(88, 159, 231)", +"hsla(240 75% 62.5%)", "rgb(88, 88, 231)", +"hsla(270 75% 62.5%)", "rgb(159, 88, 231)", +"hsla(300 75% 62.5%)", "rgb(231, 88, 231)", +"hsla(330 75% 62.5%)", "rgb(231, 88, 159)", +"hsla(0 87.5% 62.5%)", "rgb(243, 76, 76)", +"hsla(30 87.5% 62.5%)", "rgb(243, 159, 76)", +"hsla(60 87.5% 62.5%)", "rgb(243, 243, 76)", +"hsla(90 87.5% 62.5%)", "rgb(159, 243, 76)", +"hsla(120 87.5% 62.5%)", "rgb(76, 243, 76)", +"hsla(150 87.5% 62.5%)", "rgb(76, 243, 159)", +"hsla(180 87.5% 62.5%)", "rgb(76, 243, 243)", +"hsla(210 87.5% 62.5%)", "rgb(76, 159, 243)", +"hsla(240 87.5% 62.5%)", "rgb(76, 76, 243)", +"hsla(270 87.5% 62.5%)", "rgb(159, 76, 243)", +"hsla(300 87.5% 62.5%)", "rgb(243, 76, 243)", +"hsla(330 87.5% 62.5%)", "rgb(243, 76, 159)", +"hsla(0 100% 62.5%)", "rgb(255, 64, 64)", +"hsla(30 100% 62.5%)", "rgb(255, 159, 64)", +"hsla(60 100% 62.5%)", "rgb(255, 255, 64)", +"hsla(90 100% 62.5%)", "rgb(159, 255, 64)", +"hsla(120 100% 62.5%)", "rgb(64, 255, 64)", +"hsla(150 100% 62.5%)", "rgb(64, 255, 159)", +"hsla(180 100% 62.5%)", "rgb(64, 255, 255)", +"hsla(210 100% 62.5%)", "rgb(64, 159, 255)", +"hsla(240 100% 62.5%)", "rgb(64, 64, 255)", +"hsla(270 100% 62.5%)", "rgb(159, 64, 255)", +"hsla(300 100% 62.5%)", "rgb(255, 64, 255)", +"hsla(330 100% 62.5%)", "rgb(255, 64, 159)", +"hsla(0 0% 75%)", "rgb(191, 191, 191)", +"hsla(30 0% 75%)", "rgb(191, 191, 191)", +"hsla(60 0% 75%)", "rgb(191, 191, 191)", +"hsla(90 0% 75%)", "rgb(191, 191, 191)", +"hsla(120 0% 75%)", "rgb(191, 191, 191)", +"hsla(150 0% 75%)", "rgb(191, 191, 191)", +"hsla(180 0% 75%)", "rgb(191, 191, 191)", +"hsla(210 0% 75%)", "rgb(191, 191, 191)", +"hsla(240 0% 75%)", "rgb(191, 191, 191)", +"hsla(270 0% 75%)", "rgb(191, 191, 191)", +"hsla(300 0% 75%)", "rgb(191, 191, 191)", +"hsla(330 0% 75%)", "rgb(191, 191, 191)", +"hsla(0 12.5% 75%)", "rgb(199, 183, 183)", +"hsla(30 12.5% 75%)", "rgb(199, 191, 183)", +"hsla(60 12.5% 75%)", "rgb(199, 199, 183)", +"hsla(90 12.5% 75%)", "rgb(191, 199, 183)", +"hsla(120 12.5% 75%)", "rgb(183, 199, 183)", +"hsla(150 12.5% 75%)", "rgb(183, 199, 191)", +"hsla(180 12.5% 75%)", "rgb(183, 199, 199)", +"hsla(210 12.5% 75%)", "rgb(183, 191, 199)", +"hsla(240 12.5% 75%)", "rgb(183, 183, 199)", +"hsla(270 12.5% 75%)", "rgb(191, 183, 199)", +"hsla(300 12.5% 75%)", "rgb(199, 183, 199)", +"hsla(330 12.5% 75%)", "rgb(199, 183, 191)", +"hsla(0 25% 75%)", "rgb(207, 175, 175)", +"hsla(30 25% 75%)", "rgb(207, 191, 175)", +"hsla(60 25% 75%)", "rgb(207, 207, 175)", +"hsla(90 25% 75%)", "rgb(191, 207, 175)", +"hsla(120 25% 75%)", "rgb(175, 207, 175)", +"hsla(150 25% 75%)", "rgb(175, 207, 191)", +"hsla(180 25% 75%)", "rgb(175, 207, 207)", +"hsla(210 25% 75%)", "rgb(175, 191, 207)", +"hsla(240 25% 75%)", "rgb(175, 175, 207)", +"hsla(270 25% 75%)", "rgb(191, 175, 207)", +"hsla(300 25% 75%)", "rgb(207, 175, 207)", +"hsla(330 25% 75%)", "rgb(207, 175, 191)", +"hsla(0 37.5% 75%)", "rgb(215, 167, 167)", +"hsla(30 37.5% 75%)", "rgb(215, 191, 167)", +"hsla(60 37.5% 75%)", "rgb(215, 215, 167)", +"hsla(90 37.5% 75%)", "rgb(191, 215, 167)", +"hsla(120 37.5% 75%)", "rgb(167, 215, 167)", +"hsla(150 37.5% 75%)", "rgb(167, 215, 191)", +"hsla(180 37.5% 75%)", "rgb(167, 215, 215)", +"hsla(210 37.5% 75%)", "rgb(167, 191, 215)", +"hsla(240 37.5% 75%)", "rgb(167, 167, 215)", +"hsla(270 37.5% 75%)", "rgb(191, 167, 215)", +"hsla(300 37.5% 75%)", "rgb(215, 167, 215)", +"hsla(330 37.5% 75%)", "rgb(215, 167, 191)", +"hsla(0 50% 75%)", "rgb(223, 159, 159)", +"hsla(30 50% 75%)", "rgb(223, 191, 159)", +"hsla(60 50% 75%)", "rgb(223, 223, 159)", +"hsla(90 50% 75%)", "rgb(191, 223, 159)", +"hsla(120 50% 75%)", "rgb(159, 223, 159)", +"hsla(150 50% 75%)", "rgb(159, 223, 191)", +"hsla(180 50% 75%)", "rgb(159, 223, 223)", +"hsla(210 50% 75%)", "rgb(159, 191, 223)", +"hsla(240 50% 75%)", "rgb(159, 159, 223)", +"hsla(270 50% 75%)", "rgb(191, 159, 223)", +"hsla(300 50% 75%)", "rgb(223, 159, 223)", +"hsla(330 50% 75%)", "rgb(223, 159, 191)", +"hsla(0 62.5% 75%)", "rgb(231, 151, 151)", +"hsla(30 62.5% 75%)", "rgb(231, 191, 151)", +"hsla(60 62.5% 75%)", "rgb(231, 231, 151)", +"hsla(90 62.5% 75%)", "rgb(191, 231, 151)", +"hsla(120 62.5% 75%)", "rgb(151, 231, 151)", +"hsla(150 62.5% 75%)", "rgb(151, 231, 191)", +"hsla(180 62.5% 75%)", "rgb(151, 231, 231)", +"hsla(210 62.5% 75%)", "rgb(151, 191, 231)", +"hsla(240 62.5% 75%)", "rgb(151, 151, 231)", +"hsla(270 62.5% 75%)", "rgb(191, 151, 231)", +"hsla(300 62.5% 75%)", "rgb(231, 151, 231)", +"hsla(330 62.5% 75%)", "rgb(231, 151, 191)", +"hsla(0 75% 75%)", "rgb(239, 143, 143)", +"hsla(30 75% 75%)", "rgb(239, 191, 143)", +"hsla(60 75% 75%)", "rgb(239, 239, 143)", +"hsla(90 75% 75%)", "rgb(191, 239, 143)", +"hsla(120 75% 75%)", "rgb(143, 239, 143)", +"hsla(150 75% 75%)", "rgb(143, 239, 191)", +"hsla(180 75% 75%)", "rgb(143, 239, 239)", +"hsla(210 75% 75%)", "rgb(143, 191, 239)", +"hsla(240 75% 75%)", "rgb(143, 143, 239)", +"hsla(270 75% 75%)", "rgb(191, 143, 239)", +"hsla(300 75% 75%)", "rgb(239, 143, 239)", +"hsla(330 75% 75%)", "rgb(239, 143, 191)", +"hsla(0 87.5% 75%)", "rgb(247, 135, 135)", +"hsla(30 87.5% 75%)", "rgb(247, 191, 135)", +"hsla(60 87.5% 75%)", "rgb(247, 247, 135)", +"hsla(90 87.5% 75%)", "rgb(191, 247, 135)", +"hsla(120 87.5% 75%)", "rgb(135, 247, 135)", +"hsla(150 87.5% 75%)", "rgb(135, 247, 191)", +"hsla(180 87.5% 75%)", "rgb(135, 247, 247)", +"hsla(210 87.5% 75%)", "rgb(135, 191, 247)", +"hsla(240 87.5% 75%)", "rgb(135, 135, 247)", +"hsla(270 87.5% 75%)", "rgb(191, 135, 247)", +"hsla(300 87.5% 75%)", "rgb(247, 135, 247)", +"hsla(330 87.5% 75%)", "rgb(247, 135, 191)", +"hsla(0 100% 75%)", "rgb(255, 128, 128)", +"hsla(30 100% 75%)", "rgb(255, 191, 128)", +"hsla(60 100% 75%)", "rgb(255, 255, 128)", +"hsla(90 100% 75%)", "rgb(191, 255, 128)", +"hsla(120 100% 75%)", "rgb(128, 255, 128)", +"hsla(150 100% 75%)", "rgb(128, 255, 191)", +"hsla(180 100% 75%)", "rgb(128, 255, 255)", +"hsla(210 100% 75%)", "rgb(128, 191, 255)", +"hsla(240 100% 75%)", "rgb(128, 128, 255)", +"hsla(270 100% 75%)", "rgb(191, 128, 255)", +"hsla(300 100% 75%)", "rgb(255, 128, 255)", +"hsla(330 100% 75%)", "rgb(255, 128, 191)", +"hsla(0 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(30 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(60 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(90 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(120 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(150 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(180 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(210 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(240 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(270 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(300 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(330 0% 87.5%)", "rgb(223, 223, 223)", +"hsla(0 12.5% 87.5%)", "rgb(227, 219, 219)", +"hsla(30 12.5% 87.5%)", "rgb(227, 223, 219)", +"hsla(60 12.5% 87.5%)", "rgb(227, 227, 219)", +"hsla(90 12.5% 87.5%)", "rgb(223, 227, 219)", +"hsla(120 12.5% 87.5%)", "rgb(219, 227, 219)", +"hsla(150 12.5% 87.5%)", "rgb(219, 227, 223)", +"hsla(180 12.5% 87.5%)", "rgb(219, 227, 227)", +"hsla(210 12.5% 87.5%)", "rgb(219, 223, 227)", +"hsla(240 12.5% 87.5%)", "rgb(219, 219, 227)", +"hsla(270 12.5% 87.5%)", "rgb(223, 219, 227)", +"hsla(300 12.5% 87.5%)", "rgb(227, 219, 227)", +"hsla(330 12.5% 87.5%)", "rgb(227, 219, 223)", +"hsla(0 25% 87.5%)", "rgb(231, 215, 215)", +"hsla(30 25% 87.5%)", "rgb(231, 223, 215)", +"hsla(60 25% 87.5%)", "rgb(231, 231, 215)", +"hsla(90 25% 87.5%)", "rgb(223, 231, 215)", +"hsla(120 25% 87.5%)", "rgb(215, 231, 215)", +"hsla(150 25% 87.5%)", "rgb(215, 231, 223)", +"hsla(180 25% 87.5%)", "rgb(215, 231, 231)", +"hsla(210 25% 87.5%)", "rgb(215, 223, 231)", +"hsla(240 25% 87.5%)", "rgb(215, 215, 231)", +"hsla(270 25% 87.5%)", "rgb(223, 215, 231)", +"hsla(300 25% 87.5%)", "rgb(231, 215, 231)", +"hsla(330 25% 87.5%)", "rgb(231, 215, 223)", +"hsla(0 37.5% 87.5%)", "rgb(235, 211, 211)", +"hsla(30 37.5% 87.5%)", "rgb(235, 223, 211)", +"hsla(60 37.5% 87.5%)", "rgb(235, 235, 211)", +"hsla(90 37.5% 87.5%)", "rgb(223, 235, 211)", +"hsla(120 37.5% 87.5%)", "rgb(211, 235, 211)", +"hsla(150 37.5% 87.5%)", "rgb(211, 235, 223)", +"hsla(180 37.5% 87.5%)", "rgb(211, 235, 235)", +"hsla(210 37.5% 87.5%)", "rgb(211, 223, 235)", +"hsla(240 37.5% 87.5%)", "rgb(211, 211, 235)", +"hsla(270 37.5% 87.5%)", "rgb(223, 211, 235)", +"hsla(300 37.5% 87.5%)", "rgb(235, 211, 235)", +"hsla(330 37.5% 87.5%)", "rgb(235, 211, 223)", +"hsla(0 50% 87.5%)", "rgb(239, 207, 207)", +"hsla(30 50% 87.5%)", "rgb(239, 223, 207)", +"hsla(60 50% 87.5%)", "rgb(239, 239, 207)", +"hsla(90 50% 87.5%)", "rgb(223, 239, 207)", +"hsla(120 50% 87.5%)", "rgb(207, 239, 207)", +"hsla(150 50% 87.5%)", "rgb(207, 239, 223)", +"hsla(180 50% 87.5%)", "rgb(207, 239, 239)", +"hsla(210 50% 87.5%)", "rgb(207, 223, 239)", +"hsla(240 50% 87.5%)", "rgb(207, 207, 239)", +"hsla(270 50% 87.5%)", "rgb(223, 207, 239)", +"hsla(300 50% 87.5%)", "rgb(239, 207, 239)", +"hsla(330 50% 87.5%)", "rgb(239, 207, 223)", +"hsla(0 62.5% 87.5%)", "rgb(243, 203, 203)", +"hsla(30 62.5% 87.5%)", "rgb(243, 223, 203)", +"hsla(60 62.5% 87.5%)", "rgb(243, 243, 203)", +"hsla(90 62.5% 87.5%)", "rgb(223, 243, 203)", +"hsla(120 62.5% 87.5%)", "rgb(203, 243, 203)", +"hsla(150 62.5% 87.5%)", "rgb(203, 243, 223)", +"hsla(180 62.5% 87.5%)", "rgb(203, 243, 243)", +"hsla(210 62.5% 87.5%)", "rgb(203, 223, 243)", +"hsla(240 62.5% 87.5%)", "rgb(203, 203, 243)", +"hsla(270 62.5% 87.5%)", "rgb(223, 203, 243)", +"hsla(300 62.5% 87.5%)", "rgb(243, 203, 243)", +"hsla(330 62.5% 87.5%)", "rgb(243, 203, 223)", +"hsla(0 75% 87.5%)", "rgb(247, 199, 199)", +"hsla(30 75% 87.5%)", "rgb(247, 223, 199)", +"hsla(60 75% 87.5%)", "rgb(247, 247, 199)", +"hsla(90 75% 87.5%)", "rgb(223, 247, 199)", +"hsla(120 75% 87.5%)", "rgb(199, 247, 199)", +"hsla(150 75% 87.5%)", "rgb(199, 247, 223)", +"hsla(180 75% 87.5%)", "rgb(199, 247, 247)", +"hsla(210 75% 87.5%)", "rgb(199, 223, 247)", +"hsla(240 75% 87.5%)", "rgb(199, 199, 247)", +"hsla(270 75% 87.5%)", "rgb(223, 199, 247)", +"hsla(300 75% 87.5%)", "rgb(247, 199, 247)", +"hsla(330 75% 87.5%)", "rgb(247, 199, 223)", +"hsla(0 87.5% 87.5%)", "rgb(251, 195, 195)", +"hsla(30 87.5% 87.5%)", "rgb(251, 223, 195)", +"hsla(60 87.5% 87.5%)", "rgb(251, 251, 195)", +"hsla(90 87.5% 87.5%)", "rgb(223, 251, 195)", +"hsla(120 87.5% 87.5%)", "rgb(195, 251, 195)", +"hsla(150 87.5% 87.5%)", "rgb(195, 251, 223)", +"hsla(180 87.5% 87.5%)", "rgb(195, 251, 251)", +"hsla(210 87.5% 87.5%)", "rgb(195, 223, 251)", +"hsla(240 87.5% 87.5%)", "rgb(195, 195, 251)", +"hsla(270 87.5% 87.5%)", "rgb(223, 195, 251)", +"hsla(300 87.5% 87.5%)", "rgb(251, 195, 251)", +"hsla(330 87.5% 87.5%)", "rgb(251, 195, 223)", +"hsla(0 100% 87.5%)", "rgb(255, 191, 191)", +"hsla(30 100% 87.5%)", "rgb(255, 223, 191)", +"hsla(60 100% 87.5%)", "rgb(255, 255, 191)", +"hsla(90 100% 87.5%)", "rgb(223, 255, 191)", +"hsla(120 100% 87.5%)", "rgb(191, 255, 191)", +"hsla(150 100% 87.5%)", "rgb(191, 255, 223)", +"hsla(180 100% 87.5%)", "rgb(191, 255, 255)", +"hsla(210 100% 87.5%)", "rgb(191, 223, 255)", +"hsla(240 100% 87.5%)", "rgb(191, 191, 255)", +"hsla(270 100% 87.5%)", "rgb(223, 191, 255)", +"hsla(300 100% 87.5%)", "rgb(255, 191, 255)", +"hsla(330 100% 87.5%)", "rgb(255, 191, 223)", +"hsla(0 0% 100%)", "rgb(255, 255, 255)", +"hsla(30 0% 100%)", "rgb(255, 255, 255)", +"hsla(60 0% 100%)", "rgb(255, 255, 255)", +"hsla(90 0% 100%)", "rgb(255, 255, 255)", +"hsla(120 0% 100%)", "rgb(255, 255, 255)", +"hsla(150 0% 100%)", "rgb(255, 255, 255)", +"hsla(180 0% 100%)", "rgb(255, 255, 255)", +"hsla(210 0% 100%)", "rgb(255, 255, 255)", +"hsla(240 0% 100%)", "rgb(255, 255, 255)", +"hsla(270 0% 100%)", "rgb(255, 255, 255)", +"hsla(300 0% 100%)", "rgb(255, 255, 255)", +"hsla(330 0% 100%)", "rgb(255, 255, 255)", +"hsla(0 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(30 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(60 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(90 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(120 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(150 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(180 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(210 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(240 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(270 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(300 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(330 12.5% 100%)", "rgb(255, 255, 255)", +"hsla(0 25% 100%)", "rgb(255, 255, 255)", +"hsla(30 25% 100%)", "rgb(255, 255, 255)", +"hsla(60 25% 100%)", "rgb(255, 255, 255)", +"hsla(90 25% 100%)", "rgb(255, 255, 255)", +"hsla(120 25% 100%)", "rgb(255, 255, 255)", +"hsla(150 25% 100%)", "rgb(255, 255, 255)", +"hsla(180 25% 100%)", "rgb(255, 255, 255)", +"hsla(210 25% 100%)", "rgb(255, 255, 255)", +"hsla(240 25% 100%)", "rgb(255, 255, 255)", +"hsla(270 25% 100%)", "rgb(255, 255, 255)", +"hsla(300 25% 100%)", "rgb(255, 255, 255)", +"hsla(330 25% 100%)", "rgb(255, 255, 255)", +"hsla(0 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(30 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(60 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(90 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(120 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(150 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(180 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(210 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(240 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(270 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(300 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(330 37.5% 100%)", "rgb(255, 255, 255)", +"hsla(0 50% 100%)", "rgb(255, 255, 255)", +"hsla(30 50% 100%)", "rgb(255, 255, 255)", +"hsla(60 50% 100%)", "rgb(255, 255, 255)", +"hsla(90 50% 100%)", "rgb(255, 255, 255)", +"hsla(120 50% 100%)", "rgb(255, 255, 255)", +"hsla(150 50% 100%)", "rgb(255, 255, 255)", +"hsla(180 50% 100%)", "rgb(255, 255, 255)", +"hsla(210 50% 100%)", "rgb(255, 255, 255)", +"hsla(240 50% 100%)", "rgb(255, 255, 255)", +"hsla(270 50% 100%)", "rgb(255, 255, 255)", +"hsla(300 50% 100%)", "rgb(255, 255, 255)", +"hsla(330 50% 100%)", "rgb(255, 255, 255)", +"hsla(0 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(30 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(60 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(90 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(120 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(150 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(180 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(210 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(240 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(270 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(300 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(330 62.5% 100%)", "rgb(255, 255, 255)", +"hsla(0 75% 100%)", "rgb(255, 255, 255)", +"hsla(30 75% 100%)", "rgb(255, 255, 255)", +"hsla(60 75% 100%)", "rgb(255, 255, 255)", +"hsla(90 75% 100%)", "rgb(255, 255, 255)", +"hsla(120 75% 100%)", "rgb(255, 255, 255)", +"hsla(150 75% 100%)", "rgb(255, 255, 255)", +"hsla(180 75% 100%)", "rgb(255, 255, 255)", +"hsla(210 75% 100%)", "rgb(255, 255, 255)", +"hsla(240 75% 100%)", "rgb(255, 255, 255)", +"hsla(270 75% 100%)", "rgb(255, 255, 255)", +"hsla(300 75% 100%)", "rgb(255, 255, 255)", +"hsla(330 75% 100%)", "rgb(255, 255, 255)", +"hsla(0 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(30 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(60 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(90 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(120 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(150 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(180 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(210 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(240 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(270 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(300 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(330 87.5% 100%)", "rgb(255, 255, 255)", +"hsla(0 100% 100%)", "rgb(255, 255, 255)", +"hsla(30 100% 100%)", "rgb(255, 255, 255)", +"hsla(60 100% 100%)", "rgb(255, 255, 255)", +"hsla(90 100% 100%)", "rgb(255, 255, 255)", +"hsla(120 100% 100%)", "rgb(255, 255, 255)", +"hsla(150 100% 100%)", "rgb(255, 255, 255)", +"hsla(180 100% 100%)", "rgb(255, 255, 255)", +"hsla(210 100% 100%)", "rgb(255, 255, 255)", +"hsla(240 100% 100%)", "rgb(255, 255, 255)", +"hsla(270 100% 100%)", "rgb(255, 255, 255)", +"hsla(300 100% 100%)", "rgb(255, 255, 255)", +"hsla(330 100% 100%)", "rgb(255, 255, 255)", +"hsla(0 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 0% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 12.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 25% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 37.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 50% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 62.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 75% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 87.5% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(30 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(60 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(90 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(120 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(150 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(180 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(210 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(240 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(270 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(300 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(330 100% 0% / 1.0)", "rgb(0, 0, 0)", +"hsla(0 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(30 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(60 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(90 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(120 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(150 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(180 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(210 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(240 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(270 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(300 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(330 0% 12.5% / 1.0)", "rgb(32, 32, 32)", +"hsla(0 12.5% 12.5% / 1.0)", "rgb(36, 28, 28)", +"hsla(30 12.5% 12.5% / 1.0)", "rgb(36, 32, 28)", +"hsla(60 12.5% 12.5% / 1.0)", "rgb(36, 36, 28)", +"hsla(90 12.5% 12.5% / 1.0)", "rgb(32, 36, 28)", +"hsla(120 12.5% 12.5% / 1.0)", "rgb(28, 36, 28)", +"hsla(150 12.5% 12.5% / 1.0)", "rgb(28, 36, 32)", +"hsla(180 12.5% 12.5% / 1.0)", "rgb(28, 36, 36)", +"hsla(210 12.5% 12.5% / 1.0)", "rgb(28, 32, 36)", +"hsla(240 12.5% 12.5% / 1.0)", "rgb(28, 28, 36)", +"hsla(270 12.5% 12.5% / 1.0)", "rgb(32, 28, 36)", +"hsla(300 12.5% 12.5% / 1.0)", "rgb(36, 28, 36)", +"hsla(330 12.5% 12.5% / 1.0)", "rgb(36, 28, 32)", +"hsla(0 25% 12.5% / 1.0)", "rgb(40, 24, 24)", +"hsla(30 25% 12.5% / 1.0)", "rgb(40, 32, 24)", +"hsla(60 25% 12.5% / 1.0)", "rgb(40, 40, 24)", +"hsla(90 25% 12.5% / 1.0)", "rgb(32, 40, 24)", +"hsla(120 25% 12.5% / 1.0)", "rgb(24, 40, 24)", +"hsla(150 25% 12.5% / 1.0)", "rgb(24, 40, 32)", +"hsla(180 25% 12.5% / 1.0)", "rgb(24, 40, 40)", +"hsla(210 25% 12.5% / 1.0)", "rgb(24, 32, 40)", +"hsla(240 25% 12.5% / 1.0)", "rgb(24, 24, 40)", +"hsla(270 25% 12.5% / 1.0)", "rgb(32, 24, 40)", +"hsla(300 25% 12.5% / 1.0)", "rgb(40, 24, 40)", +"hsla(330 25% 12.5% / 1.0)", "rgb(40, 24, 32)", +"hsla(0 37.5% 12.5% / 1.0)", "rgb(44, 20, 20)", +"hsla(30 37.5% 12.5% / 1.0)", "rgb(44, 32, 20)", +"hsla(60 37.5% 12.5% / 1.0)", "rgb(44, 44, 20)", +"hsla(90 37.5% 12.5% / 1.0)", "rgb(32, 44, 20)", +"hsla(120 37.5% 12.5% / 1.0)", "rgb(20, 44, 20)", +"hsla(150 37.5% 12.5% / 1.0)", "rgb(20, 44, 32)", +"hsla(180 37.5% 12.5% / 1.0)", "rgb(20, 44, 44)", +"hsla(210 37.5% 12.5% / 1.0)", "rgb(20, 32, 44)", +"hsla(240 37.5% 12.5% / 1.0)", "rgb(20, 20, 44)", +"hsla(270 37.5% 12.5% / 1.0)", "rgb(32, 20, 44)", +"hsla(300 37.5% 12.5% / 1.0)", "rgb(44, 20, 44)", +"hsla(330 37.5% 12.5% / 1.0)", "rgb(44, 20, 32)", +"hsla(0 50% 12.5% / 1.0)", "rgb(48, 16, 16)", +"hsla(30 50% 12.5% / 1.0)", "rgb(48, 32, 16)", +"hsla(60 50% 12.5% / 1.0)", "rgb(48, 48, 16)", +"hsla(90 50% 12.5% / 1.0)", "rgb(32, 48, 16)", +"hsla(120 50% 12.5% / 1.0)", "rgb(16, 48, 16)", +"hsla(150 50% 12.5% / 1.0)", "rgb(16, 48, 32)", +"hsla(180 50% 12.5% / 1.0)", "rgb(16, 48, 48)", +"hsla(210 50% 12.5% / 1.0)", "rgb(16, 32, 48)", +"hsla(240 50% 12.5% / 1.0)", "rgb(16, 16, 48)", +"hsla(270 50% 12.5% / 1.0)", "rgb(32, 16, 48)", +"hsla(300 50% 12.5% / 1.0)", "rgb(48, 16, 48)", +"hsla(330 50% 12.5% / 1.0)", "rgb(48, 16, 32)", +"hsla(0 62.5% 12.5% / 1.0)", "rgb(52, 12, 12)", +"hsla(30 62.5% 12.5% / 1.0)", "rgb(52, 32, 12)", +"hsla(60 62.5% 12.5% / 1.0)", "rgb(52, 52, 12)", +"hsla(90 62.5% 12.5% / 1.0)", "rgb(32, 52, 12)", +"hsla(120 62.5% 12.5% / 1.0)", "rgb(12, 52, 12)", +"hsla(150 62.5% 12.5% / 1.0)", "rgb(12, 52, 32)", +"hsla(180 62.5% 12.5% / 1.0)", "rgb(12, 52, 52)", +"hsla(210 62.5% 12.5% / 1.0)", "rgb(12, 32, 52)", +"hsla(240 62.5% 12.5% / 1.0)", "rgb(12, 12, 52)", +"hsla(270 62.5% 12.5% / 1.0)", "rgb(32, 12, 52)", +"hsla(300 62.5% 12.5% / 1.0)", "rgb(52, 12, 52)", +"hsla(330 62.5% 12.5% / 1.0)", "rgb(52, 12, 32)", +"hsla(0 75% 12.5% / 1.0)", "rgb(56, 8, 8)", +"hsla(30 75% 12.5% / 1.0)", "rgb(56, 32, 8)", +"hsla(60 75% 12.5% / 1.0)", "rgb(56, 56, 8)", +"hsla(90 75% 12.5% / 1.0)", "rgb(32, 56, 8)", +"hsla(120 75% 12.5% / 1.0)", "rgb(8, 56, 8)", +"hsla(150 75% 12.5% / 1.0)", "rgb(8, 56, 32)", +"hsla(180 75% 12.5% / 1.0)", "rgb(8, 56, 56)", +"hsla(210 75% 12.5% / 1.0)", "rgb(8, 32, 56)", +"hsla(240 75% 12.5% / 1.0)", "rgb(8, 8, 56)", +"hsla(270 75% 12.5% / 1.0)", "rgb(32, 8, 56)", +"hsla(300 75% 12.5% / 1.0)", "rgb(56, 8, 56)", +"hsla(330 75% 12.5% / 1.0)", "rgb(56, 8, 32)", +"hsla(0 87.5% 12.5% / 1.0)", "rgb(60, 4, 4)", +"hsla(30 87.5% 12.5% / 1.0)", "rgb(60, 32, 4)", +"hsla(60 87.5% 12.5% / 1.0)", "rgb(60, 60, 4)", +"hsla(90 87.5% 12.5% / 1.0)", "rgb(32, 60, 4)", +"hsla(120 87.5% 12.5% / 1.0)", "rgb(4, 60, 4)", +"hsla(150 87.5% 12.5% / 1.0)", "rgb(4, 60, 32)", +"hsla(180 87.5% 12.5% / 1.0)", "rgb(4, 60, 60)", +"hsla(210 87.5% 12.5% / 1.0)", "rgb(4, 32, 60)", +"hsla(240 87.5% 12.5% / 1.0)", "rgb(4, 4, 60)", +"hsla(270 87.5% 12.5% / 1.0)", "rgb(32, 4, 60)", +"hsla(300 87.5% 12.5% / 1.0)", "rgb(60, 4, 60)", +"hsla(330 87.5% 12.5% / 1.0)", "rgb(60, 4, 32)", +"hsla(0 100% 12.5% / 1.0)", "rgb(64, 0, 0)", +"hsla(30 100% 12.5% / 1.0)", "rgb(64, 32, 0)", +"hsla(60 100% 12.5% / 1.0)", "rgb(64, 64, 0)", +"hsla(90 100% 12.5% / 1.0)", "rgb(32, 64, 0)", +"hsla(120 100% 12.5% / 1.0)", "rgb(0, 64, 0)", +"hsla(150 100% 12.5% / 1.0)", "rgb(0, 64, 32)", +"hsla(180 100% 12.5% / 1.0)", "rgb(0, 64, 64)", +"hsla(210 100% 12.5% / 1.0)", "rgb(0, 32, 64)", +"hsla(240 100% 12.5% / 1.0)", "rgb(0, 0, 64)", +"hsla(270 100% 12.5% / 1.0)", "rgb(32, 0, 64)", +"hsla(300 100% 12.5% / 1.0)", "rgb(64, 0, 64)", +"hsla(330 100% 12.5% / 1.0)", "rgb(64, 0, 32)", +"hsla(0 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(30 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(60 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(90 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(120 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(150 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(180 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(210 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(240 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(270 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(300 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(330 0% 25% / 1.0)", "rgb(64, 64, 64)", +"hsla(0 12.5% 25% / 1.0)", "rgb(72, 56, 56)", +"hsla(30 12.5% 25% / 1.0)", "rgb(72, 64, 56)", +"hsla(60 12.5% 25% / 1.0)", "rgb(72, 72, 56)", +"hsla(90 12.5% 25% / 1.0)", "rgb(64, 72, 56)", +"hsla(120 12.5% 25% / 1.0)", "rgb(56, 72, 56)", +"hsla(150 12.5% 25% / 1.0)", "rgb(56, 72, 64)", +"hsla(180 12.5% 25% / 1.0)", "rgb(56, 72, 72)", +"hsla(210 12.5% 25% / 1.0)", "rgb(56, 64, 72)", +"hsla(240 12.5% 25% / 1.0)", "rgb(56, 56, 72)", +"hsla(270 12.5% 25% / 1.0)", "rgb(64, 56, 72)", +"hsla(300 12.5% 25% / 1.0)", "rgb(72, 56, 72)", +"hsla(330 12.5% 25% / 1.0)", "rgb(72, 56, 64)", +"hsla(0 25% 25% / 1.0)", "rgb(80, 48, 48)", +"hsla(30 25% 25% / 1.0)", "rgb(80, 64, 48)", +"hsla(60 25% 25% / 1.0)", "rgb(80, 80, 48)", +"hsla(90 25% 25% / 1.0)", "rgb(64, 80, 48)", +"hsla(120 25% 25% / 1.0)", "rgb(48, 80, 48)", +"hsla(150 25% 25% / 1.0)", "rgb(48, 80, 64)", +"hsla(180 25% 25% / 1.0)", "rgb(48, 80, 80)", +"hsla(210 25% 25% / 1.0)", "rgb(48, 64, 80)", +"hsla(240 25% 25% / 1.0)", "rgb(48, 48, 80)", +"hsla(270 25% 25% / 1.0)", "rgb(64, 48, 80)", +"hsla(300 25% 25% / 1.0)", "rgb(80, 48, 80)", +"hsla(330 25% 25% / 1.0)", "rgb(80, 48, 64)", +"hsla(0 37.5% 25% / 1.0)", "rgb(88, 40, 40)", +"hsla(30 37.5% 25% / 1.0)", "rgb(88, 64, 40)", +"hsla(60 37.5% 25% / 1.0)", "rgb(88, 88, 40)", +"hsla(90 37.5% 25% / 1.0)", "rgb(64, 88, 40)", +"hsla(120 37.5% 25% / 1.0)", "rgb(40, 88, 40)", +"hsla(150 37.5% 25% / 1.0)", "rgb(40, 88, 64)", +"hsla(180 37.5% 25% / 1.0)", "rgb(40, 88, 88)", +"hsla(210 37.5% 25% / 1.0)", "rgb(40, 64, 88)", +"hsla(240 37.5% 25% / 1.0)", "rgb(40, 40, 88)", +"hsla(270 37.5% 25% / 1.0)", "rgb(64, 40, 88)", +"hsla(300 37.5% 25% / 1.0)", "rgb(88, 40, 88)", +"hsla(330 37.5% 25% / 1.0)", "rgb(88, 40, 64)", +"hsla(0 50% 25% / 1.0)", "rgb(96, 32, 32)", +"hsla(30 50% 25% / 1.0)", "rgb(96, 64, 32)", +"hsla(60 50% 25% / 1.0)", "rgb(96, 96, 32)", +"hsla(90 50% 25% / 1.0)", "rgb(64, 96, 32)", +"hsla(120 50% 25% / 1.0)", "rgb(32, 96, 32)", +"hsla(150 50% 25% / 1.0)", "rgb(32, 96, 64)", +"hsla(180 50% 25% / 1.0)", "rgb(32, 96, 96)", +"hsla(210 50% 25% / 1.0)", "rgb(32, 64, 96)", +"hsla(240 50% 25% / 1.0)", "rgb(32, 32, 96)", +"hsla(270 50% 25% / 1.0)", "rgb(64, 32, 96)", +"hsla(300 50% 25% / 1.0)", "rgb(96, 32, 96)", +"hsla(330 50% 25% / 1.0)", "rgb(96, 32, 64)", +"hsla(0 62.5% 25% / 1.0)", "rgb(104, 24, 24)", +"hsla(30 62.5% 25% / 1.0)", "rgb(104, 64, 24)", +"hsla(60 62.5% 25% / 1.0)", "rgb(104, 104, 24)", +"hsla(90 62.5% 25% / 1.0)", "rgb(64, 104, 24)", +"hsla(120 62.5% 25% / 1.0)", "rgb(24, 104, 24)", +"hsla(150 62.5% 25% / 1.0)", "rgb(24, 104, 64)", +"hsla(180 62.5% 25% / 1.0)", "rgb(24, 104, 104)", +"hsla(210 62.5% 25% / 1.0)", "rgb(24, 64, 104)", +"hsla(240 62.5% 25% / 1.0)", "rgb(24, 24, 104)", +"hsla(270 62.5% 25% / 1.0)", "rgb(64, 24, 104)", +"hsla(300 62.5% 25% / 1.0)", "rgb(104, 24, 104)", +"hsla(330 62.5% 25% / 1.0)", "rgb(104, 24, 64)", +"hsla(0 75% 25% / 1.0)", "rgb(112, 16, 16)", +"hsla(30 75% 25% / 1.0)", "rgb(112, 64, 16)", +"hsla(60 75% 25% / 1.0)", "rgb(112, 112, 16)", +"hsla(90 75% 25% / 1.0)", "rgb(64, 112, 16)", +"hsla(120 75% 25% / 1.0)", "rgb(16, 112, 16)", +"hsla(150 75% 25% / 1.0)", "rgb(16, 112, 64)", +"hsla(180 75% 25% / 1.0)", "rgb(16, 112, 112)", +"hsla(210 75% 25% / 1.0)", "rgb(16, 64, 112)", +"hsla(240 75% 25% / 1.0)", "rgb(16, 16, 112)", +"hsla(270 75% 25% / 1.0)", "rgb(64, 16, 112)", +"hsla(300 75% 25% / 1.0)", "rgb(112, 16, 112)", +"hsla(330 75% 25% / 1.0)", "rgb(112, 16, 64)", +"hsla(0 87.5% 25% / 1.0)", "rgb(120, 8, 8)", +"hsla(30 87.5% 25% / 1.0)", "rgb(120, 64, 8)", +"hsla(60 87.5% 25% / 1.0)", "rgb(120, 120, 8)", +"hsla(90 87.5% 25% / 1.0)", "rgb(64, 120, 8)", +"hsla(120 87.5% 25% / 1.0)", "rgb(8, 120, 8)", +"hsla(150 87.5% 25% / 1.0)", "rgb(8, 120, 64)", +"hsla(180 87.5% 25% / 1.0)", "rgb(8, 120, 120)", +"hsla(210 87.5% 25% / 1.0)", "rgb(8, 64, 120)", +"hsla(240 87.5% 25% / 1.0)", "rgb(8, 8, 120)", +"hsla(270 87.5% 25% / 1.0)", "rgb(64, 8, 120)", +"hsla(300 87.5% 25% / 1.0)", "rgb(120, 8, 120)", +"hsla(330 87.5% 25% / 1.0)", "rgb(120, 8, 64)", +"hsla(0 100% 25% / 1.0)", "rgb(128, 0, 0)", +"hsla(30 100% 25% / 1.0)", "rgb(128, 64, 0)", +"hsla(60 100% 25% / 1.0)", "rgb(128, 128, 0)", +"hsla(90 100% 25% / 1.0)", "rgb(64, 128, 0)", +"hsla(120 100% 25% / 1.0)", "rgb(0, 128, 0)", +"hsla(150 100% 25% / 1.0)", "rgb(0, 128, 64)", +"hsla(180 100% 25% / 1.0)", "rgb(0, 128, 128)", +"hsla(210 100% 25% / 1.0)", "rgb(0, 64, 128)", +"hsla(240 100% 25% / 1.0)", "rgb(0, 0, 128)", +"hsla(270 100% 25% / 1.0)", "rgb(64, 0, 128)", +"hsla(300 100% 25% / 1.0)", "rgb(128, 0, 128)", +"hsla(330 100% 25% / 1.0)", "rgb(128, 0, 64)", +"hsla(0 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(30 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(60 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(90 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(120 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(150 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(180 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(210 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(240 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(270 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(300 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(330 0% 37.5% / 1.0)", "rgb(96, 96, 96)", +"hsla(0 12.5% 37.5% / 1.0)", "rgb(108, 84, 84)", +"hsla(30 12.5% 37.5% / 1.0)", "rgb(108, 96, 84)", +"hsla(60 12.5% 37.5% / 1.0)", "rgb(108, 108, 84)", +"hsla(90 12.5% 37.5% / 1.0)", "rgb(96, 108, 84)", +"hsla(120 12.5% 37.5% / 1.0)", "rgb(84, 108, 84)", +"hsla(150 12.5% 37.5% / 1.0)", "rgb(84, 108, 96)", +"hsla(180 12.5% 37.5% / 1.0)", "rgb(84, 108, 108)", +"hsla(210 12.5% 37.5% / 1.0)", "rgb(84, 96, 108)", +"hsla(240 12.5% 37.5% / 1.0)", "rgb(84, 84, 108)", +"hsla(270 12.5% 37.5% / 1.0)", "rgb(96, 84, 108)", +"hsla(300 12.5% 37.5% / 1.0)", "rgb(108, 84, 108)", +"hsla(330 12.5% 37.5% / 1.0)", "rgb(108, 84, 96)", +"hsla(0 25% 37.5% / 1.0)", "rgb(120, 72, 72)", +"hsla(30 25% 37.5% / 1.0)", "rgb(120, 96, 72)", +"hsla(60 25% 37.5% / 1.0)", "rgb(120, 120, 72)", +"hsla(90 25% 37.5% / 1.0)", "rgb(96, 120, 72)", +"hsla(120 25% 37.5% / 1.0)", "rgb(72, 120, 72)", +"hsla(150 25% 37.5% / 1.0)", "rgb(72, 120, 96)", +"hsla(180 25% 37.5% / 1.0)", "rgb(72, 120, 120)", +"hsla(210 25% 37.5% / 1.0)", "rgb(72, 96, 120)", +"hsla(240 25% 37.5% / 1.0)", "rgb(72, 72, 120)", +"hsla(270 25% 37.5% / 1.0)", "rgb(96, 72, 120)", +"hsla(300 25% 37.5% / 1.0)", "rgb(120, 72, 120)", +"hsla(330 25% 37.5% / 1.0)", "rgb(120, 72, 96)", +"hsla(0 37.5% 37.5% / 1.0)", "rgb(131, 60, 60)", +"hsla(30 37.5% 37.5% / 1.0)", "rgb(131, 96, 60)", +"hsla(60 37.5% 37.5% / 1.0)", "rgb(131, 131, 60)", +"hsla(90 37.5% 37.5% / 1.0)", "rgb(96, 131, 60)", +"hsla(120 37.5% 37.5% / 1.0)", "rgb(60, 131, 60)", +"hsla(150 37.5% 37.5% / 1.0)", "rgb(60, 131, 96)", +"hsla(180 37.5% 37.5% / 1.0)", "rgb(60, 131, 131)", +"hsla(210 37.5% 37.5% / 1.0)", "rgb(60, 96, 131)", +"hsla(240 37.5% 37.5% / 1.0)", "rgb(60, 60, 131)", +"hsla(270 37.5% 37.5% / 1.0)", "rgb(96, 60, 131)", +"hsla(300 37.5% 37.5% / 1.0)", "rgb(131, 60, 131)", +"hsla(330 37.5% 37.5% / 1.0)", "rgb(131, 60, 96)", +"hsla(0 50% 37.5% / 1.0)", "rgb(143, 48, 48)", +"hsla(30 50% 37.5% / 1.0)", "rgb(143, 96, 48)", +"hsla(60 50% 37.5% / 1.0)", "rgb(143, 143, 48)", +"hsla(90 50% 37.5% / 1.0)", "rgb(96, 143, 48)", +"hsla(120 50% 37.5% / 1.0)", "rgb(48, 143, 48)", +"hsla(150 50% 37.5% / 1.0)", "rgb(48, 143, 96)", +"hsla(180 50% 37.5% / 1.0)", "rgb(48, 143, 143)", +"hsla(210 50% 37.5% / 1.0)", "rgb(48, 96, 143)", +"hsla(240 50% 37.5% / 1.0)", "rgb(48, 48, 143)", +"hsla(270 50% 37.5% / 1.0)", "rgb(96, 48, 143)", +"hsla(300 50% 37.5% / 1.0)", "rgb(143, 48, 143)", +"hsla(330 50% 37.5% / 1.0)", "rgb(143, 48, 96)", +"hsla(0 62.5% 37.5% / 1.0)", "rgb(155, 36, 36)", +"hsla(30 62.5% 37.5% / 1.0)", "rgb(155, 96, 36)", +"hsla(60 62.5% 37.5% / 1.0)", "rgb(155, 155, 36)", +"hsla(90 62.5% 37.5% / 1.0)", "rgb(96, 155, 36)", +"hsla(120 62.5% 37.5% / 1.0)", "rgb(36, 155, 36)", +"hsla(150 62.5% 37.5% / 1.0)", "rgb(36, 155, 96)", +"hsla(180 62.5% 37.5% / 1.0)", "rgb(36, 155, 155)", +"hsla(210 62.5% 37.5% / 1.0)", "rgb(36, 96, 155)", +"hsla(240 62.5% 37.5% / 1.0)", "rgb(36, 36, 155)", +"hsla(270 62.5% 37.5% / 1.0)", "rgb(96, 36, 155)", +"hsla(300 62.5% 37.5% / 1.0)", "rgb(155, 36, 155)", +"hsla(330 62.5% 37.5% / 1.0)", "rgb(155, 36, 96)", +"hsla(0 75% 37.5% / 1.0)", "rgb(167, 24, 24)", +"hsla(30 75% 37.5% / 1.0)", "rgb(167, 96, 24)", +"hsla(60 75% 37.5% / 1.0)", "rgb(167, 167, 24)", +"hsla(90 75% 37.5% / 1.0)", "rgb(96, 167, 24)", +"hsla(120 75% 37.5% / 1.0)", "rgb(24, 167, 24)", +"hsla(150 75% 37.5% / 1.0)", "rgb(24, 167, 96)", +"hsla(180 75% 37.5% / 1.0)", "rgb(24, 167, 167)", +"hsla(210 75% 37.5% / 1.0)", "rgb(24, 96, 167)", +"hsla(240 75% 37.5% / 1.0)", "rgb(24, 24, 167)", +"hsla(270 75% 37.5% / 1.0)", "rgb(96, 24, 167)", +"hsla(300 75% 37.5% / 1.0)", "rgb(167, 24, 167)", +"hsla(330 75% 37.5% / 1.0)", "rgb(167, 24, 96)", +"hsla(0 87.5% 37.5% / 1.0)", "rgb(179, 12, 12)", +"hsla(30 87.5% 37.5% / 1.0)", "rgb(179, 96, 12)", +"hsla(60 87.5% 37.5% / 1.0)", "rgb(179, 179, 12)", +"hsla(90 87.5% 37.5% / 1.0)", "rgb(96, 179, 12)", +"hsla(120 87.5% 37.5% / 1.0)", "rgb(12, 179, 12)", +"hsla(150 87.5% 37.5% / 1.0)", "rgb(12, 179, 96)", +"hsla(180 87.5% 37.5% / 1.0)", "rgb(12, 179, 179)", +"hsla(210 87.5% 37.5% / 1.0)", "rgb(12, 96, 179)", +"hsla(240 87.5% 37.5% / 1.0)", "rgb(12, 12, 179)", +"hsla(270 87.5% 37.5% / 1.0)", "rgb(96, 12, 179)", +"hsla(300 87.5% 37.5% / 1.0)", "rgb(179, 12, 179)", +"hsla(330 87.5% 37.5% / 1.0)", "rgb(179, 12, 96)", +"hsla(0 100% 37.5% / 1.0)", "rgb(191, 0, 0)", +"hsla(30 100% 37.5% / 1.0)", "rgb(191, 96, 0)", +"hsla(60 100% 37.5% / 1.0)", "rgb(191, 191, 0)", +"hsla(90 100% 37.5% / 1.0)", "rgb(96, 191, 0)", +"hsla(120 100% 37.5% / 1.0)", "rgb(0, 191, 0)", +"hsla(150 100% 37.5% / 1.0)", "rgb(0, 191, 96)", +"hsla(180 100% 37.5% / 1.0)", "rgb(0, 191, 191)", +"hsla(210 100% 37.5% / 1.0)", "rgb(0, 96, 191)", +"hsla(240 100% 37.5% / 1.0)", "rgb(0, 0, 191)", +"hsla(270 100% 37.5% / 1.0)", "rgb(96, 0, 191)", +"hsla(300 100% 37.5% / 1.0)", "rgb(191, 0, 191)", +"hsla(330 100% 37.5% / 1.0)", "rgb(191, 0, 96)", +"hsla(0 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(30 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(60 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(90 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(120 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(150 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(180 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(210 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(240 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(270 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(300 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(330 0% 50% / 1.0)", "rgb(128, 128, 128)", +"hsla(0 12.5% 50% / 1.0)", "rgb(143, 112, 112)", +"hsla(30 12.5% 50% / 1.0)", "rgb(143, 128, 112)", +"hsla(60 12.5% 50% / 1.0)", "rgb(143, 143, 112)", +"hsla(90 12.5% 50% / 1.0)", "rgb(128, 143, 112)", +"hsla(120 12.5% 50% / 1.0)", "rgb(112, 143, 112)", +"hsla(150 12.5% 50% / 1.0)", "rgb(112, 143, 128)", +"hsla(180 12.5% 50% / 1.0)", "rgb(112, 143, 143)", +"hsla(210 12.5% 50% / 1.0)", "rgb(112, 128, 143)", +"hsla(240 12.5% 50% / 1.0)", "rgb(112, 112, 143)", +"hsla(270 12.5% 50% / 1.0)", "rgb(128, 112, 143)", +"hsla(300 12.5% 50% / 1.0)", "rgb(143, 112, 143)", +"hsla(330 12.5% 50% / 1.0)", "rgb(143, 112, 128)", +"hsla(0 25% 50% / 1.0)", "rgb(159, 96, 96)", +"hsla(30 25% 50% / 1.0)", "rgb(159, 128, 96)", +"hsla(60 25% 50% / 1.0)", "rgb(159, 159, 96)", +"hsla(90 25% 50% / 1.0)", "rgb(128, 159, 96)", +"hsla(120 25% 50% / 1.0)", "rgb(96, 159, 96)", +"hsla(150 25% 50% / 1.0)", "rgb(96, 159, 128)", +"hsla(180 25% 50% / 1.0)", "rgb(96, 159, 159)", +"hsla(210 25% 50% / 1.0)", "rgb(96, 128, 159)", +"hsla(240 25% 50% / 1.0)", "rgb(96, 96, 159)", +"hsla(270 25% 50% / 1.0)", "rgb(128, 96, 159)", +"hsla(300 25% 50% / 1.0)", "rgb(159, 96, 159)", +"hsla(330 25% 50% / 1.0)", "rgb(159, 96, 128)", +"hsla(0 37.5% 50% / 1.0)", "rgb(175, 80, 80)", +"hsla(30 37.5% 50% / 1.0)", "rgb(175, 128, 80)", +"hsla(60 37.5% 50% / 1.0)", "rgb(175, 175, 80)", +"hsla(90 37.5% 50% / 1.0)", "rgb(128, 175, 80)", +"hsla(120 37.5% 50% / 1.0)", "rgb(80, 175, 80)", +"hsla(150 37.5% 50% / 1.0)", "rgb(80, 175, 128)", +"hsla(180 37.5% 50% / 1.0)", "rgb(80, 175, 175)", +"hsla(210 37.5% 50% / 1.0)", "rgb(80, 128, 175)", +"hsla(240 37.5% 50% / 1.0)", "rgb(80, 80, 175)", +"hsla(270 37.5% 50% / 1.0)", "rgb(128, 80, 175)", +"hsla(300 37.5% 50% / 1.0)", "rgb(175, 80, 175)", +"hsla(330 37.5% 50% / 1.0)", "rgb(175, 80, 128)", +"hsla(0 50% 50% / 1.0)", "rgb(191, 64, 64)", +"hsla(30 50% 50% / 1.0)", "rgb(191, 128, 64)", +"hsla(60 50% 50% / 1.0)", "rgb(191, 191, 64)", +"hsla(90 50% 50% / 1.0)", "rgb(128, 191, 64)", +"hsla(120 50% 50% / 1.0)", "rgb(64, 191, 64)", +"hsla(150 50% 50% / 1.0)", "rgb(64, 191, 128)", +"hsla(180 50% 50% / 1.0)", "rgb(64, 191, 191)", +"hsla(210 50% 50% / 1.0)", "rgb(64, 128, 191)", +"hsla(240 50% 50% / 1.0)", "rgb(64, 64, 191)", +"hsla(270 50% 50% / 1.0)", "rgb(128, 64, 191)", +"hsla(300 50% 50% / 1.0)", "rgb(191, 64, 191)", +"hsla(330 50% 50% / 1.0)", "rgb(191, 64, 128)", +"hsla(0 62.5% 50% / 1.0)", "rgb(207, 48, 48)", +"hsla(30 62.5% 50% / 1.0)", "rgb(207, 128, 48)", +"hsla(60 62.5% 50% / 1.0)", "rgb(207, 207, 48)", +"hsla(90 62.5% 50% / 1.0)", "rgb(128, 207, 48)", +"hsla(120 62.5% 50% / 1.0)", "rgb(48, 207, 48)", +"hsla(150 62.5% 50% / 1.0)", "rgb(48, 207, 128)", +"hsla(180 62.5% 50% / 1.0)", "rgb(48, 207, 207)", +"hsla(210 62.5% 50% / 1.0)", "rgb(48, 128, 207)", +"hsla(240 62.5% 50% / 1.0)", "rgb(48, 48, 207)", +"hsla(270 62.5% 50% / 1.0)", "rgb(128, 48, 207)", +"hsla(300 62.5% 50% / 1.0)", "rgb(207, 48, 207)", +"hsla(330 62.5% 50% / 1.0)", "rgb(207, 48, 128)", +"hsla(0 75% 50% / 1.0)", "rgb(223, 32, 32)", +"hsla(30 75% 50% / 1.0)", "rgb(223, 128, 32)", +"hsla(60 75% 50% / 1.0)", "rgb(223, 223, 32)", +"hsla(90 75% 50% / 1.0)", "rgb(128, 223, 32)", +"hsla(120 75% 50% / 1.0)", "rgb(32, 223, 32)", +"hsla(150 75% 50% / 1.0)", "rgb(32, 223, 128)", +"hsla(180 75% 50% / 1.0)", "rgb(32, 223, 223)", +"hsla(210 75% 50% / 1.0)", "rgb(32, 128, 223)", +"hsla(240 75% 50% / 1.0)", "rgb(32, 32, 223)", +"hsla(270 75% 50% / 1.0)", "rgb(128, 32, 223)", +"hsla(300 75% 50% / 1.0)", "rgb(223, 32, 223)", +"hsla(330 75% 50% / 1.0)", "rgb(223, 32, 128)", +"hsla(0 87.5% 50% / 1.0)", "rgb(239, 16, 16)", +"hsla(30 87.5% 50% / 1.0)", "rgb(239, 128, 16)", +"hsla(60 87.5% 50% / 1.0)", "rgb(239, 239, 16)", +"hsla(90 87.5% 50% / 1.0)", "rgb(128, 239, 16)", +"hsla(120 87.5% 50% / 1.0)", "rgb(16, 239, 16)", +"hsla(150 87.5% 50% / 1.0)", "rgb(16, 239, 128)", +"hsla(180 87.5% 50% / 1.0)", "rgb(16, 239, 239)", +"hsla(210 87.5% 50% / 1.0)", "rgb(16, 128, 239)", +"hsla(240 87.5% 50% / 1.0)", "rgb(16, 16, 239)", +"hsla(270 87.5% 50% / 1.0)", "rgb(128, 16, 239)", +"hsla(300 87.5% 50% / 1.0)", "rgb(239, 16, 239)", +"hsla(330 87.5% 50% / 1.0)", "rgb(239, 16, 128)", +"hsla(0 100% 50% / 1.0)", "rgb(255, 0, 0)", +"hsla(30 100% 50% / 1.0)", "rgb(255, 128, 0)", +"hsla(60 100% 50% / 1.0)", "rgb(255, 255, 0)", +"hsla(90 100% 50% / 1.0)", "rgb(128, 255, 0)", +"hsla(120 100% 50% / 1.0)", "rgb(0, 255, 0)", +"hsla(150 100% 50% / 1.0)", "rgb(0, 255, 128)", +"hsla(180 100% 50% / 1.0)", "rgb(0, 255, 255)", +"hsla(210 100% 50% / 1.0)", "rgb(0, 128, 255)", +"hsla(240 100% 50% / 1.0)", "rgb(0, 0, 255)", +"hsla(270 100% 50% / 1.0)", "rgb(128, 0, 255)", +"hsla(300 100% 50% / 1.0)", "rgb(255, 0, 255)", +"hsla(330 100% 50% / 1.0)", "rgb(255, 0, 128)", +"hsla(0 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(30 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(60 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(90 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(120 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(150 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(180 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(210 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(240 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(270 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(300 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(330 0% 62.5% / 1.0)", "rgb(159, 159, 159)", +"hsla(0 12.5% 62.5% / 1.0)", "rgb(171, 147, 147)", +"hsla(30 12.5% 62.5% / 1.0)", "rgb(171, 159, 147)", +"hsla(60 12.5% 62.5% / 1.0)", "rgb(171, 171, 147)", +"hsla(90 12.5% 62.5% / 1.0)", "rgb(159, 171, 147)", +"hsla(120 12.5% 62.5% / 1.0)", "rgb(147, 171, 147)", +"hsla(150 12.5% 62.5% / 1.0)", "rgb(147, 171, 159)", +"hsla(180 12.5% 62.5% / 1.0)", "rgb(147, 171, 171)", +"hsla(210 12.5% 62.5% / 1.0)", "rgb(147, 159, 171)", +"hsla(240 12.5% 62.5% / 1.0)", "rgb(147, 147, 171)", +"hsla(270 12.5% 62.5% / 1.0)", "rgb(159, 147, 171)", +"hsla(300 12.5% 62.5% / 1.0)", "rgb(171, 147, 171)", +"hsla(330 12.5% 62.5% / 1.0)", "rgb(171, 147, 159)", +"hsla(0 25% 62.5% / 1.0)", "rgb(183, 135, 135)", +"hsla(30 25% 62.5% / 1.0)", "rgb(183, 159, 135)", +"hsla(60 25% 62.5% / 1.0)", "rgb(183, 183, 135)", +"hsla(90 25% 62.5% / 1.0)", "rgb(159, 183, 135)", +"hsla(120 25% 62.5% / 1.0)", "rgb(135, 183, 135)", +"hsla(150 25% 62.5% / 1.0)", "rgb(135, 183, 159)", +"hsla(180 25% 62.5% / 1.0)", "rgb(135, 183, 183)", +"hsla(210 25% 62.5% / 1.0)", "rgb(135, 159, 183)", +"hsla(240 25% 62.5% / 1.0)", "rgb(135, 135, 183)", +"hsla(270 25% 62.5% / 1.0)", "rgb(159, 135, 183)", +"hsla(300 25% 62.5% / 1.0)", "rgb(183, 135, 183)", +"hsla(330 25% 62.5% / 1.0)", "rgb(183, 135, 159)", +"hsla(0 37.5% 62.5% / 1.0)", "rgb(195, 124, 124)", +"hsla(30 37.5% 62.5% / 1.0)", "rgb(195, 159, 124)", +"hsla(60 37.5% 62.5% / 1.0)", "rgb(195, 195, 124)", +"hsla(90 37.5% 62.5% / 1.0)", "rgb(159, 195, 124)", +"hsla(120 37.5% 62.5% / 1.0)", "rgb(124, 195, 124)", +"hsla(150 37.5% 62.5% / 1.0)", "rgb(124, 195, 159)", +"hsla(180 37.5% 62.5% / 1.0)", "rgb(124, 195, 195)", +"hsla(210 37.5% 62.5% / 1.0)", "rgb(124, 159, 195)", +"hsla(240 37.5% 62.5% / 1.0)", "rgb(124, 124, 195)", +"hsla(270 37.5% 62.5% / 1.0)", "rgb(159, 124, 195)", +"hsla(300 37.5% 62.5% / 1.0)", "rgb(195, 124, 195)", +"hsla(330 37.5% 62.5% / 1.0)", "rgb(195, 124, 159)", +"hsla(0 50% 62.5% / 1.0)", "rgb(207, 112, 112)", +"hsla(30 50% 62.5% / 1.0)", "rgb(207, 159, 112)", +"hsla(60 50% 62.5% / 1.0)", "rgb(207, 207, 112)", +"hsla(90 50% 62.5% / 1.0)", "rgb(159, 207, 112)", +"hsla(120 50% 62.5% / 1.0)", "rgb(112, 207, 112)", +"hsla(150 50% 62.5% / 1.0)", "rgb(112, 207, 159)", +"hsla(180 50% 62.5% / 1.0)", "rgb(112, 207, 207)", +"hsla(210 50% 62.5% / 1.0)", "rgb(112, 159, 207)", +"hsla(240 50% 62.5% / 1.0)", "rgb(112, 112, 207)", +"hsla(270 50% 62.5% / 1.0)", "rgb(159, 112, 207)", +"hsla(300 50% 62.5% / 1.0)", "rgb(207, 112, 207)", +"hsla(330 50% 62.5% / 1.0)", "rgb(207, 112, 159)", +"hsla(0 62.5% 62.5% / 1.0)", "rgb(219, 100, 100)", +"hsla(30 62.5% 62.5% / 1.0)", "rgb(219, 159, 100)", +"hsla(60 62.5% 62.5% / 1.0)", "rgb(219, 219, 100)", +"hsla(90 62.5% 62.5% / 1.0)", "rgb(159, 219, 100)", +"hsla(120 62.5% 62.5% / 1.0)", "rgb(100, 219, 100)", +"hsla(150 62.5% 62.5% / 1.0)", "rgb(100, 219, 159)", +"hsla(180 62.5% 62.5% / 1.0)", "rgb(100, 219, 219)", +"hsla(210 62.5% 62.5% / 1.0)", "rgb(100, 159, 219)", +"hsla(240 62.5% 62.5% / 1.0)", "rgb(100, 100, 219)", +"hsla(270 62.5% 62.5% / 1.0)", "rgb(159, 100, 219)", +"hsla(300 62.5% 62.5% / 1.0)", "rgb(219, 100, 219)", +"hsla(330 62.5% 62.5% / 1.0)", "rgb(219, 100, 159)", +"hsla(0 75% 62.5% / 1.0)", "rgb(231, 88, 88)", +"hsla(30 75% 62.5% / 1.0)", "rgb(231, 159, 88)", +"hsla(60 75% 62.5% / 1.0)", "rgb(231, 231, 88)", +"hsla(90 75% 62.5% / 1.0)", "rgb(159, 231, 88)", +"hsla(120 75% 62.5% / 1.0)", "rgb(88, 231, 88)", +"hsla(150 75% 62.5% / 1.0)", "rgb(88, 231, 159)", +"hsla(180 75% 62.5% / 1.0)", "rgb(88, 231, 231)", +"hsla(210 75% 62.5% / 1.0)", "rgb(88, 159, 231)", +"hsla(240 75% 62.5% / 1.0)", "rgb(88, 88, 231)", +"hsla(270 75% 62.5% / 1.0)", "rgb(159, 88, 231)", +"hsla(300 75% 62.5% / 1.0)", "rgb(231, 88, 231)", +"hsla(330 75% 62.5% / 1.0)", "rgb(231, 88, 159)", +"hsla(0 87.5% 62.5% / 1.0)", "rgb(243, 76, 76)", +"hsla(30 87.5% 62.5% / 1.0)", "rgb(243, 159, 76)", +"hsla(60 87.5% 62.5% / 1.0)", "rgb(243, 243, 76)", +"hsla(90 87.5% 62.5% / 1.0)", "rgb(159, 243, 76)", +"hsla(120 87.5% 62.5% / 1.0)", "rgb(76, 243, 76)", +"hsla(150 87.5% 62.5% / 1.0)", "rgb(76, 243, 159)", +"hsla(180 87.5% 62.5% / 1.0)", "rgb(76, 243, 243)", +"hsla(210 87.5% 62.5% / 1.0)", "rgb(76, 159, 243)", +"hsla(240 87.5% 62.5% / 1.0)", "rgb(76, 76, 243)", +"hsla(270 87.5% 62.5% / 1.0)", "rgb(159, 76, 243)", +"hsla(300 87.5% 62.5% / 1.0)", "rgb(243, 76, 243)", +"hsla(330 87.5% 62.5% / 1.0)", "rgb(243, 76, 159)", +"hsla(0 100% 62.5% / 1.0)", "rgb(255, 64, 64)", +"hsla(30 100% 62.5% / 1.0)", "rgb(255, 159, 64)", +"hsla(60 100% 62.5% / 1.0)", "rgb(255, 255, 64)", +"hsla(90 100% 62.5% / 1.0)", "rgb(159, 255, 64)", +"hsla(120 100% 62.5% / 1.0)", "rgb(64, 255, 64)", +"hsla(150 100% 62.5% / 1.0)", "rgb(64, 255, 159)", +"hsla(180 100% 62.5% / 1.0)", "rgb(64, 255, 255)", +"hsla(210 100% 62.5% / 1.0)", "rgb(64, 159, 255)", +"hsla(240 100% 62.5% / 1.0)", "rgb(64, 64, 255)", +"hsla(270 100% 62.5% / 1.0)", "rgb(159, 64, 255)", +"hsla(300 100% 62.5% / 1.0)", "rgb(255, 64, 255)", +"hsla(330 100% 62.5% / 1.0)", "rgb(255, 64, 159)", +"hsla(0 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(30 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(60 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(90 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(120 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(150 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(180 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(210 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(240 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(270 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(300 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(330 0% 75% / 1.0)", "rgb(191, 191, 191)", +"hsla(0 12.5% 75% / 1.0)", "rgb(199, 183, 183)", +"hsla(30 12.5% 75% / 1.0)", "rgb(199, 191, 183)", +"hsla(60 12.5% 75% / 1.0)", "rgb(199, 199, 183)", +"hsla(90 12.5% 75% / 1.0)", "rgb(191, 199, 183)", +"hsla(120 12.5% 75% / 1.0)", "rgb(183, 199, 183)", +"hsla(150 12.5% 75% / 1.0)", "rgb(183, 199, 191)", +"hsla(180 12.5% 75% / 1.0)", "rgb(183, 199, 199)", +"hsla(210 12.5% 75% / 1.0)", "rgb(183, 191, 199)", +"hsla(240 12.5% 75% / 1.0)", "rgb(183, 183, 199)", +"hsla(270 12.5% 75% / 1.0)", "rgb(191, 183, 199)", +"hsla(300 12.5% 75% / 1.0)", "rgb(199, 183, 199)", +"hsla(330 12.5% 75% / 1.0)", "rgb(199, 183, 191)", +"hsla(0 25% 75% / 1.0)", "rgb(207, 175, 175)", +"hsla(30 25% 75% / 1.0)", "rgb(207, 191, 175)", +"hsla(60 25% 75% / 1.0)", "rgb(207, 207, 175)", +"hsla(90 25% 75% / 1.0)", "rgb(191, 207, 175)", +"hsla(120 25% 75% / 1.0)", "rgb(175, 207, 175)", +"hsla(150 25% 75% / 1.0)", "rgb(175, 207, 191)", +"hsla(180 25% 75% / 1.0)", "rgb(175, 207, 207)", +"hsla(210 25% 75% / 1.0)", "rgb(175, 191, 207)", +"hsla(240 25% 75% / 1.0)", "rgb(175, 175, 207)", +"hsla(270 25% 75% / 1.0)", "rgb(191, 175, 207)", +"hsla(300 25% 75% / 1.0)", "rgb(207, 175, 207)", +"hsla(330 25% 75% / 1.0)", "rgb(207, 175, 191)", +"hsla(0 37.5% 75% / 1.0)", "rgb(215, 167, 167)", +"hsla(30 37.5% 75% / 1.0)", "rgb(215, 191, 167)", +"hsla(60 37.5% 75% / 1.0)", "rgb(215, 215, 167)", +"hsla(90 37.5% 75% / 1.0)", "rgb(191, 215, 167)", +"hsla(120 37.5% 75% / 1.0)", "rgb(167, 215, 167)", +"hsla(150 37.5% 75% / 1.0)", "rgb(167, 215, 191)", +"hsla(180 37.5% 75% / 1.0)", "rgb(167, 215, 215)", +"hsla(210 37.5% 75% / 1.0)", "rgb(167, 191, 215)", +"hsla(240 37.5% 75% / 1.0)", "rgb(167, 167, 215)", +"hsla(270 37.5% 75% / 1.0)", "rgb(191, 167, 215)", +"hsla(300 37.5% 75% / 1.0)", "rgb(215, 167, 215)", +"hsla(330 37.5% 75% / 1.0)", "rgb(215, 167, 191)", +"hsla(0 50% 75% / 1.0)", "rgb(223, 159, 159)", +"hsla(30 50% 75% / 1.0)", "rgb(223, 191, 159)", +"hsla(60 50% 75% / 1.0)", "rgb(223, 223, 159)", +"hsla(90 50% 75% / 1.0)", "rgb(191, 223, 159)", +"hsla(120 50% 75% / 1.0)", "rgb(159, 223, 159)", +"hsla(150 50% 75% / 1.0)", "rgb(159, 223, 191)", +"hsla(180 50% 75% / 1.0)", "rgb(159, 223, 223)", +"hsla(210 50% 75% / 1.0)", "rgb(159, 191, 223)", +"hsla(240 50% 75% / 1.0)", "rgb(159, 159, 223)", +"hsla(270 50% 75% / 1.0)", "rgb(191, 159, 223)", +"hsla(300 50% 75% / 1.0)", "rgb(223, 159, 223)", +"hsla(330 50% 75% / 1.0)", "rgb(223, 159, 191)", +"hsla(0 62.5% 75% / 1.0)", "rgb(231, 151, 151)", +"hsla(30 62.5% 75% / 1.0)", "rgb(231, 191, 151)", +"hsla(60 62.5% 75% / 1.0)", "rgb(231, 231, 151)", +"hsla(90 62.5% 75% / 1.0)", "rgb(191, 231, 151)", +"hsla(120 62.5% 75% / 1.0)", "rgb(151, 231, 151)", +"hsla(150 62.5% 75% / 1.0)", "rgb(151, 231, 191)", +"hsla(180 62.5% 75% / 1.0)", "rgb(151, 231, 231)", +"hsla(210 62.5% 75% / 1.0)", "rgb(151, 191, 231)", +"hsla(240 62.5% 75% / 1.0)", "rgb(151, 151, 231)", +"hsla(270 62.5% 75% / 1.0)", "rgb(191, 151, 231)", +"hsla(300 62.5% 75% / 1.0)", "rgb(231, 151, 231)", +"hsla(330 62.5% 75% / 1.0)", "rgb(231, 151, 191)", +"hsla(0 75% 75% / 1.0)", "rgb(239, 143, 143)", +"hsla(30 75% 75% / 1.0)", "rgb(239, 191, 143)", +"hsla(60 75% 75% / 1.0)", "rgb(239, 239, 143)", +"hsla(90 75% 75% / 1.0)", "rgb(191, 239, 143)", +"hsla(120 75% 75% / 1.0)", "rgb(143, 239, 143)", +"hsla(150 75% 75% / 1.0)", "rgb(143, 239, 191)", +"hsla(180 75% 75% / 1.0)", "rgb(143, 239, 239)", +"hsla(210 75% 75% / 1.0)", "rgb(143, 191, 239)", +"hsla(240 75% 75% / 1.0)", "rgb(143, 143, 239)", +"hsla(270 75% 75% / 1.0)", "rgb(191, 143, 239)", +"hsla(300 75% 75% / 1.0)", "rgb(239, 143, 239)", +"hsla(330 75% 75% / 1.0)", "rgb(239, 143, 191)", +"hsla(0 87.5% 75% / 1.0)", "rgb(247, 135, 135)", +"hsla(30 87.5% 75% / 1.0)", "rgb(247, 191, 135)", +"hsla(60 87.5% 75% / 1.0)", "rgb(247, 247, 135)", +"hsla(90 87.5% 75% / 1.0)", "rgb(191, 247, 135)", +"hsla(120 87.5% 75% / 1.0)", "rgb(135, 247, 135)", +"hsla(150 87.5% 75% / 1.0)", "rgb(135, 247, 191)", +"hsla(180 87.5% 75% / 1.0)", "rgb(135, 247, 247)", +"hsla(210 87.5% 75% / 1.0)", "rgb(135, 191, 247)", +"hsla(240 87.5% 75% / 1.0)", "rgb(135, 135, 247)", +"hsla(270 87.5% 75% / 1.0)", "rgb(191, 135, 247)", +"hsla(300 87.5% 75% / 1.0)", "rgb(247, 135, 247)", +"hsla(330 87.5% 75% / 1.0)", "rgb(247, 135, 191)", +"hsla(0 100% 75% / 1.0)", "rgb(255, 128, 128)", +"hsla(30 100% 75% / 1.0)", "rgb(255, 191, 128)", +"hsla(60 100% 75% / 1.0)", "rgb(255, 255, 128)", +"hsla(90 100% 75% / 1.0)", "rgb(191, 255, 128)", +"hsla(120 100% 75% / 1.0)", "rgb(128, 255, 128)", +"hsla(150 100% 75% / 1.0)", "rgb(128, 255, 191)", +"hsla(180 100% 75% / 1.0)", "rgb(128, 255, 255)", +"hsla(210 100% 75% / 1.0)", "rgb(128, 191, 255)", +"hsla(240 100% 75% / 1.0)", "rgb(128, 128, 255)", +"hsla(270 100% 75% / 1.0)", "rgb(191, 128, 255)", +"hsla(300 100% 75% / 1.0)", "rgb(255, 128, 255)", +"hsla(330 100% 75% / 1.0)", "rgb(255, 128, 191)", +"hsla(0 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(30 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(60 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(90 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(120 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(150 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(180 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(210 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(240 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(270 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(300 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(330 0% 87.5% / 1.0)", "rgb(223, 223, 223)", +"hsla(0 12.5% 87.5% / 1.0)", "rgb(227, 219, 219)", +"hsla(30 12.5% 87.5% / 1.0)", "rgb(227, 223, 219)", +"hsla(60 12.5% 87.5% / 1.0)", "rgb(227, 227, 219)", +"hsla(90 12.5% 87.5% / 1.0)", "rgb(223, 227, 219)", +"hsla(120 12.5% 87.5% / 1.0)", "rgb(219, 227, 219)", +"hsla(150 12.5% 87.5% / 1.0)", "rgb(219, 227, 223)", +"hsla(180 12.5% 87.5% / 1.0)", "rgb(219, 227, 227)", +"hsla(210 12.5% 87.5% / 1.0)", "rgb(219, 223, 227)", +"hsla(240 12.5% 87.5% / 1.0)", "rgb(219, 219, 227)", +"hsla(270 12.5% 87.5% / 1.0)", "rgb(223, 219, 227)", +"hsla(300 12.5% 87.5% / 1.0)", "rgb(227, 219, 227)", +"hsla(330 12.5% 87.5% / 1.0)", "rgb(227, 219, 223)", +"hsla(0 25% 87.5% / 1.0)", "rgb(231, 215, 215)", +"hsla(30 25% 87.5% / 1.0)", "rgb(231, 223, 215)", +"hsla(60 25% 87.5% / 1.0)", "rgb(231, 231, 215)", +"hsla(90 25% 87.5% / 1.0)", "rgb(223, 231, 215)", +"hsla(120 25% 87.5% / 1.0)", "rgb(215, 231, 215)", +"hsla(150 25% 87.5% / 1.0)", "rgb(215, 231, 223)", +"hsla(180 25% 87.5% / 1.0)", "rgb(215, 231, 231)", +"hsla(210 25% 87.5% / 1.0)", "rgb(215, 223, 231)", +"hsla(240 25% 87.5% / 1.0)", "rgb(215, 215, 231)", +"hsla(270 25% 87.5% / 1.0)", "rgb(223, 215, 231)", +"hsla(300 25% 87.5% / 1.0)", "rgb(231, 215, 231)", +"hsla(330 25% 87.5% / 1.0)", "rgb(231, 215, 223)", +"hsla(0 37.5% 87.5% / 1.0)", "rgb(235, 211, 211)", +"hsla(30 37.5% 87.5% / 1.0)", "rgb(235, 223, 211)", +"hsla(60 37.5% 87.5% / 1.0)", "rgb(235, 235, 211)", +"hsla(90 37.5% 87.5% / 1.0)", "rgb(223, 235, 211)", +"hsla(120 37.5% 87.5% / 1.0)", "rgb(211, 235, 211)", +"hsla(150 37.5% 87.5% / 1.0)", "rgb(211, 235, 223)", +"hsla(180 37.5% 87.5% / 1.0)", "rgb(211, 235, 235)", +"hsla(210 37.5% 87.5% / 1.0)", "rgb(211, 223, 235)", +"hsla(240 37.5% 87.5% / 1.0)", "rgb(211, 211, 235)", +"hsla(270 37.5% 87.5% / 1.0)", "rgb(223, 211, 235)", +"hsla(300 37.5% 87.5% / 1.0)", "rgb(235, 211, 235)", +"hsla(330 37.5% 87.5% / 1.0)", "rgb(235, 211, 223)", +"hsla(0 50% 87.5% / 1.0)", "rgb(239, 207, 207)", +"hsla(30 50% 87.5% / 1.0)", "rgb(239, 223, 207)", +"hsla(60 50% 87.5% / 1.0)", "rgb(239, 239, 207)", +"hsla(90 50% 87.5% / 1.0)", "rgb(223, 239, 207)", +"hsla(120 50% 87.5% / 1.0)", "rgb(207, 239, 207)", +"hsla(150 50% 87.5% / 1.0)", "rgb(207, 239, 223)", +"hsla(180 50% 87.5% / 1.0)", "rgb(207, 239, 239)", +"hsla(210 50% 87.5% / 1.0)", "rgb(207, 223, 239)", +"hsla(240 50% 87.5% / 1.0)", "rgb(207, 207, 239)", +"hsla(270 50% 87.5% / 1.0)", "rgb(223, 207, 239)", +"hsla(300 50% 87.5% / 1.0)", "rgb(239, 207, 239)", +"hsla(330 50% 87.5% / 1.0)", "rgb(239, 207, 223)", +"hsla(0 62.5% 87.5% / 1.0)", "rgb(243, 203, 203)", +"hsla(30 62.5% 87.5% / 1.0)", "rgb(243, 223, 203)", +"hsla(60 62.5% 87.5% / 1.0)", "rgb(243, 243, 203)", +"hsla(90 62.5% 87.5% / 1.0)", "rgb(223, 243, 203)", +"hsla(120 62.5% 87.5% / 1.0)", "rgb(203, 243, 203)", +"hsla(150 62.5% 87.5% / 1.0)", "rgb(203, 243, 223)", +"hsla(180 62.5% 87.5% / 1.0)", "rgb(203, 243, 243)", +"hsla(210 62.5% 87.5% / 1.0)", "rgb(203, 223, 243)", +"hsla(240 62.5% 87.5% / 1.0)", "rgb(203, 203, 243)", +"hsla(270 62.5% 87.5% / 1.0)", "rgb(223, 203, 243)", +"hsla(300 62.5% 87.5% / 1.0)", "rgb(243, 203, 243)", +"hsla(330 62.5% 87.5% / 1.0)", "rgb(243, 203, 223)", +"hsla(0 75% 87.5% / 1.0)", "rgb(247, 199, 199)", +"hsla(30 75% 87.5% / 1.0)", "rgb(247, 223, 199)", +"hsla(60 75% 87.5% / 1.0)", "rgb(247, 247, 199)", +"hsla(90 75% 87.5% / 1.0)", "rgb(223, 247, 199)", +"hsla(120 75% 87.5% / 1.0)", "rgb(199, 247, 199)", +"hsla(150 75% 87.5% / 1.0)", "rgb(199, 247, 223)", +"hsla(180 75% 87.5% / 1.0)", "rgb(199, 247, 247)", +"hsla(210 75% 87.5% / 1.0)", "rgb(199, 223, 247)", +"hsla(240 75% 87.5% / 1.0)", "rgb(199, 199, 247)", +"hsla(270 75% 87.5% / 1.0)", "rgb(223, 199, 247)", +"hsla(300 75% 87.5% / 1.0)", "rgb(247, 199, 247)", +"hsla(330 75% 87.5% / 1.0)", "rgb(247, 199, 223)", +"hsla(0 87.5% 87.5% / 1.0)", "rgb(251, 195, 195)", +"hsla(30 87.5% 87.5% / 1.0)", "rgb(251, 223, 195)", +"hsla(60 87.5% 87.5% / 1.0)", "rgb(251, 251, 195)", +"hsla(90 87.5% 87.5% / 1.0)", "rgb(223, 251, 195)", +"hsla(120 87.5% 87.5% / 1.0)", "rgb(195, 251, 195)", +"hsla(150 87.5% 87.5% / 1.0)", "rgb(195, 251, 223)", +"hsla(180 87.5% 87.5% / 1.0)", "rgb(195, 251, 251)", +"hsla(210 87.5% 87.5% / 1.0)", "rgb(195, 223, 251)", +"hsla(240 87.5% 87.5% / 1.0)", "rgb(195, 195, 251)", +"hsla(270 87.5% 87.5% / 1.0)", "rgb(223, 195, 251)", +"hsla(300 87.5% 87.5% / 1.0)", "rgb(251, 195, 251)", +"hsla(330 87.5% 87.5% / 1.0)", "rgb(251, 195, 223)", +"hsla(0 100% 87.5% / 1.0)", "rgb(255, 191, 191)", +"hsla(30 100% 87.5% / 1.0)", "rgb(255, 223, 191)", +"hsla(60 100% 87.5% / 1.0)", "rgb(255, 255, 191)", +"hsla(90 100% 87.5% / 1.0)", "rgb(223, 255, 191)", +"hsla(120 100% 87.5% / 1.0)", "rgb(191, 255, 191)", +"hsla(150 100% 87.5% / 1.0)", "rgb(191, 255, 223)", +"hsla(180 100% 87.5% / 1.0)", "rgb(191, 255, 255)", +"hsla(210 100% 87.5% / 1.0)", "rgb(191, 223, 255)", +"hsla(240 100% 87.5% / 1.0)", "rgb(191, 191, 255)", +"hsla(270 100% 87.5% / 1.0)", "rgb(223, 191, 255)", +"hsla(300 100% 87.5% / 1.0)", "rgb(255, 191, 255)", +"hsla(330 100% 87.5% / 1.0)", "rgb(255, 191, 223)", +"hsla(0 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 0% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 12.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 25% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 37.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 50% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 62.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 75% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 87.5% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(30 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(60 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(90 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(120 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(150 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(180 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(210 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(240 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(270 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(300 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(330 100% 100% / 1.0)", "rgb(255, 255, 255)", +"hsla(0 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 0% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 12.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 25% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 37.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 50% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 62.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 75% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 87.5% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(30 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(60 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(90 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(120 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(150 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(180 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(210 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(240 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(270 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(300 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(330 100% 0% / 0.25)", "rgba(0, 0, 0, 0.25)", +"hsla(0 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(30 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(60 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(90 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(120 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(150 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(180 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(210 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(240 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(270 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(300 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(330 0% 12.5% / 0.25)", "rgba(32, 32, 32, 0.25)", +"hsla(0 12.5% 12.5% / 0.25)", "rgba(36, 28, 28, 0.25)", +"hsla(30 12.5% 12.5% / 0.25)", "rgba(36, 32, 28, 0.25)", +"hsla(60 12.5% 12.5% / 0.25)", "rgba(36, 36, 28, 0.25)", +"hsla(90 12.5% 12.5% / 0.25)", "rgba(32, 36, 28, 0.25)", +"hsla(120 12.5% 12.5% / 0.25)", "rgba(28, 36, 28, 0.25)", +"hsla(150 12.5% 12.5% / 0.25)", "rgba(28, 36, 32, 0.25)", +"hsla(180 12.5% 12.5% / 0.25)", "rgba(28, 36, 36, 0.25)", +"hsla(210 12.5% 12.5% / 0.25)", "rgba(28, 32, 36, 0.25)", +"hsla(240 12.5% 12.5% / 0.25)", "rgba(28, 28, 36, 0.25)", +"hsla(270 12.5% 12.5% / 0.25)", "rgba(32, 28, 36, 0.25)", +"hsla(300 12.5% 12.5% / 0.25)", "rgba(36, 28, 36, 0.25)", +"hsla(330 12.5% 12.5% / 0.25)", "rgba(36, 28, 32, 0.25)", +"hsla(0 25% 12.5% / 0.25)", "rgba(40, 24, 24, 0.25)", +"hsla(30 25% 12.5% / 0.25)", "rgba(40, 32, 24, 0.25)", +"hsla(60 25% 12.5% / 0.25)", "rgba(40, 40, 24, 0.25)", +"hsla(90 25% 12.5% / 0.25)", "rgba(32, 40, 24, 0.25)", +"hsla(120 25% 12.5% / 0.25)", "rgba(24, 40, 24, 0.25)", +"hsla(150 25% 12.5% / 0.25)", "rgba(24, 40, 32, 0.25)", +"hsla(180 25% 12.5% / 0.25)", "rgba(24, 40, 40, 0.25)", +"hsla(210 25% 12.5% / 0.25)", "rgba(24, 32, 40, 0.25)", +"hsla(240 25% 12.5% / 0.25)", "rgba(24, 24, 40, 0.25)", +"hsla(270 25% 12.5% / 0.25)", "rgba(32, 24, 40, 0.25)", +"hsla(300 25% 12.5% / 0.25)", "rgba(40, 24, 40, 0.25)", +"hsla(330 25% 12.5% / 0.25)", "rgba(40, 24, 32, 0.25)", +"hsla(0 37.5% 12.5% / 0.25)", "rgba(44, 20, 20, 0.25)", +"hsla(30 37.5% 12.5% / 0.25)", "rgba(44, 32, 20, 0.25)", +"hsla(60 37.5% 12.5% / 0.25)", "rgba(44, 44, 20, 0.25)", +"hsla(90 37.5% 12.5% / 0.25)", "rgba(32, 44, 20, 0.25)", +"hsla(120 37.5% 12.5% / 0.25)", "rgba(20, 44, 20, 0.25)", +"hsla(150 37.5% 12.5% / 0.25)", "rgba(20, 44, 32, 0.25)", +"hsla(180 37.5% 12.5% / 0.25)", "rgba(20, 44, 44, 0.25)", +"hsla(210 37.5% 12.5% / 0.25)", "rgba(20, 32, 44, 0.25)", +"hsla(240 37.5% 12.5% / 0.25)", "rgba(20, 20, 44, 0.25)", +"hsla(270 37.5% 12.5% / 0.25)", "rgba(32, 20, 44, 0.25)", +"hsla(300 37.5% 12.5% / 0.25)", "rgba(44, 20, 44, 0.25)", +"hsla(330 37.5% 12.5% / 0.25)", "rgba(44, 20, 32, 0.25)", +"hsla(0 50% 12.5% / 0.25)", "rgba(48, 16, 16, 0.25)", +"hsla(30 50% 12.5% / 0.25)", "rgba(48, 32, 16, 0.25)", +"hsla(60 50% 12.5% / 0.25)", "rgba(48, 48, 16, 0.25)", +"hsla(90 50% 12.5% / 0.25)", "rgba(32, 48, 16, 0.25)", +"hsla(120 50% 12.5% / 0.25)", "rgba(16, 48, 16, 0.25)", +"hsla(150 50% 12.5% / 0.25)", "rgba(16, 48, 32, 0.25)", +"hsla(180 50% 12.5% / 0.25)", "rgba(16, 48, 48, 0.25)", +"hsla(210 50% 12.5% / 0.25)", "rgba(16, 32, 48, 0.25)", +"hsla(240 50% 12.5% / 0.25)", "rgba(16, 16, 48, 0.25)", +"hsla(270 50% 12.5% / 0.25)", "rgba(32, 16, 48, 0.25)", +"hsla(300 50% 12.5% / 0.25)", "rgba(48, 16, 48, 0.25)", +"hsla(330 50% 12.5% / 0.25)", "rgba(48, 16, 32, 0.25)", +"hsla(0 62.5% 12.5% / 0.25)", "rgba(52, 12, 12, 0.25)", +"hsla(30 62.5% 12.5% / 0.25)", "rgba(52, 32, 12, 0.25)", +"hsla(60 62.5% 12.5% / 0.25)", "rgba(52, 52, 12, 0.25)", +"hsla(90 62.5% 12.5% / 0.25)", "rgba(32, 52, 12, 0.25)", +"hsla(120 62.5% 12.5% / 0.25)", "rgba(12, 52, 12, 0.25)", +"hsla(150 62.5% 12.5% / 0.25)", "rgba(12, 52, 32, 0.25)", +"hsla(180 62.5% 12.5% / 0.25)", "rgba(12, 52, 52, 0.25)", +"hsla(210 62.5% 12.5% / 0.25)", "rgba(12, 32, 52, 0.25)", +"hsla(240 62.5% 12.5% / 0.25)", "rgba(12, 12, 52, 0.25)", +"hsla(270 62.5% 12.5% / 0.25)", "rgba(32, 12, 52, 0.25)", +"hsla(300 62.5% 12.5% / 0.25)", "rgba(52, 12, 52, 0.25)", +"hsla(330 62.5% 12.5% / 0.25)", "rgba(52, 12, 32, 0.25)", +"hsla(0 75% 12.5% / 0.25)", "rgba(56, 8, 8, 0.25)", +"hsla(30 75% 12.5% / 0.25)", "rgba(56, 32, 8, 0.25)", +"hsla(60 75% 12.5% / 0.25)", "rgba(56, 56, 8, 0.25)", +"hsla(90 75% 12.5% / 0.25)", "rgba(32, 56, 8, 0.25)", +"hsla(120 75% 12.5% / 0.25)", "rgba(8, 56, 8, 0.25)", +"hsla(150 75% 12.5% / 0.25)", "rgba(8, 56, 32, 0.25)", +"hsla(180 75% 12.5% / 0.25)", "rgba(8, 56, 56, 0.25)", +"hsla(210 75% 12.5% / 0.25)", "rgba(8, 32, 56, 0.25)", +"hsla(240 75% 12.5% / 0.25)", "rgba(8, 8, 56, 0.25)", +"hsla(270 75% 12.5% / 0.25)", "rgba(32, 8, 56, 0.25)", +"hsla(300 75% 12.5% / 0.25)", "rgba(56, 8, 56, 0.25)", +"hsla(330 75% 12.5% / 0.25)", "rgba(56, 8, 32, 0.25)", +"hsla(0 87.5% 12.5% / 0.25)", "rgba(60, 4, 4, 0.25)", +"hsla(30 87.5% 12.5% / 0.25)", "rgba(60, 32, 4, 0.25)", +"hsla(60 87.5% 12.5% / 0.25)", "rgba(60, 60, 4, 0.25)", +"hsla(90 87.5% 12.5% / 0.25)", "rgba(32, 60, 4, 0.25)", +"hsla(120 87.5% 12.5% / 0.25)", "rgba(4, 60, 4, 0.25)", +"hsla(150 87.5% 12.5% / 0.25)", "rgba(4, 60, 32, 0.25)", +"hsla(180 87.5% 12.5% / 0.25)", "rgba(4, 60, 60, 0.25)", +"hsla(210 87.5% 12.5% / 0.25)", "rgba(4, 32, 60, 0.25)", +"hsla(240 87.5% 12.5% / 0.25)", "rgba(4, 4, 60, 0.25)", +"hsla(270 87.5% 12.5% / 0.25)", "rgba(32, 4, 60, 0.25)", +"hsla(300 87.5% 12.5% / 0.25)", "rgba(60, 4, 60, 0.25)", +"hsla(330 87.5% 12.5% / 0.25)", "rgba(60, 4, 32, 0.25)", +"hsla(0 100% 12.5% / 0.25)", "rgba(64, 0, 0, 0.25)", +"hsla(30 100% 12.5% / 0.25)", "rgba(64, 32, 0, 0.25)", +"hsla(60 100% 12.5% / 0.25)", "rgba(64, 64, 0, 0.25)", +"hsla(90 100% 12.5% / 0.25)", "rgba(32, 64, 0, 0.25)", +"hsla(120 100% 12.5% / 0.25)", "rgba(0, 64, 0, 0.25)", +"hsla(150 100% 12.5% / 0.25)", "rgba(0, 64, 32, 0.25)", +"hsla(180 100% 12.5% / 0.25)", "rgba(0, 64, 64, 0.25)", +"hsla(210 100% 12.5% / 0.25)", "rgba(0, 32, 64, 0.25)", +"hsla(240 100% 12.5% / 0.25)", "rgba(0, 0, 64, 0.25)", +"hsla(270 100% 12.5% / 0.25)", "rgba(32, 0, 64, 0.25)", +"hsla(300 100% 12.5% / 0.25)", "rgba(64, 0, 64, 0.25)", +"hsla(330 100% 12.5% / 0.25)", "rgba(64, 0, 32, 0.25)", +"hsla(0 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(30 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(60 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(90 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(120 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(150 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(180 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(210 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(240 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(270 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(300 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(330 0% 25% / 0.25)", "rgba(64, 64, 64, 0.25)", +"hsla(0 12.5% 25% / 0.25)", "rgba(72, 56, 56, 0.25)", +"hsla(30 12.5% 25% / 0.25)", "rgba(72, 64, 56, 0.25)", +"hsla(60 12.5% 25% / 0.25)", "rgba(72, 72, 56, 0.25)", +"hsla(90 12.5% 25% / 0.25)", "rgba(64, 72, 56, 0.25)", +"hsla(120 12.5% 25% / 0.25)", "rgba(56, 72, 56, 0.25)", +"hsla(150 12.5% 25% / 0.25)", "rgba(56, 72, 64, 0.25)", +"hsla(180 12.5% 25% / 0.25)", "rgba(56, 72, 72, 0.25)", +"hsla(210 12.5% 25% / 0.25)", "rgba(56, 64, 72, 0.25)", +"hsla(240 12.5% 25% / 0.25)", "rgba(56, 56, 72, 0.25)", +"hsla(270 12.5% 25% / 0.25)", "rgba(64, 56, 72, 0.25)", +"hsla(300 12.5% 25% / 0.25)", "rgba(72, 56, 72, 0.25)", +"hsla(330 12.5% 25% / 0.25)", "rgba(72, 56, 64, 0.25)", +"hsla(0 25% 25% / 0.25)", "rgba(80, 48, 48, 0.25)", +"hsla(30 25% 25% / 0.25)", "rgba(80, 64, 48, 0.25)", +"hsla(60 25% 25% / 0.25)", "rgba(80, 80, 48, 0.25)", +"hsla(90 25% 25% / 0.25)", "rgba(64, 80, 48, 0.25)", +"hsla(120 25% 25% / 0.25)", "rgba(48, 80, 48, 0.25)", +"hsla(150 25% 25% / 0.25)", "rgba(48, 80, 64, 0.25)", +"hsla(180 25% 25% / 0.25)", "rgba(48, 80, 80, 0.25)", +"hsla(210 25% 25% / 0.25)", "rgba(48, 64, 80, 0.25)", +"hsla(240 25% 25% / 0.25)", "rgba(48, 48, 80, 0.25)", +"hsla(270 25% 25% / 0.25)", "rgba(64, 48, 80, 0.25)", +"hsla(300 25% 25% / 0.25)", "rgba(80, 48, 80, 0.25)", +"hsla(330 25% 25% / 0.25)", "rgba(80, 48, 64, 0.25)", +"hsla(0 37.5% 25% / 0.25)", "rgba(88, 40, 40, 0.25)", +"hsla(30 37.5% 25% / 0.25)", "rgba(88, 64, 40, 0.25)", +"hsla(60 37.5% 25% / 0.25)", "rgba(88, 88, 40, 0.25)", +"hsla(90 37.5% 25% / 0.25)", "rgba(64, 88, 40, 0.25)", +"hsla(120 37.5% 25% / 0.25)", "rgba(40, 88, 40, 0.25)", +"hsla(150 37.5% 25% / 0.25)", "rgba(40, 88, 64, 0.25)", +"hsla(180 37.5% 25% / 0.25)", "rgba(40, 88, 88, 0.25)", +"hsla(210 37.5% 25% / 0.25)", "rgba(40, 64, 88, 0.25)", +"hsla(240 37.5% 25% / 0.25)", "rgba(40, 40, 88, 0.25)", +"hsla(270 37.5% 25% / 0.25)", "rgba(64, 40, 88, 0.25)", +"hsla(300 37.5% 25% / 0.25)", "rgba(88, 40, 88, 0.25)", +"hsla(330 37.5% 25% / 0.25)", "rgba(88, 40, 64, 0.25)", +"hsla(0 50% 25% / 0.25)", "rgba(96, 32, 32, 0.25)", +"hsla(30 50% 25% / 0.25)", "rgba(96, 64, 32, 0.25)", +"hsla(60 50% 25% / 0.25)", "rgba(96, 96, 32, 0.25)", +"hsla(90 50% 25% / 0.25)", "rgba(64, 96, 32, 0.25)", +"hsla(120 50% 25% / 0.25)", "rgba(32, 96, 32, 0.25)", +"hsla(150 50% 25% / 0.25)", "rgba(32, 96, 64, 0.25)", +"hsla(180 50% 25% / 0.25)", "rgba(32, 96, 96, 0.25)", +"hsla(210 50% 25% / 0.25)", "rgba(32, 64, 96, 0.25)", +"hsla(240 50% 25% / 0.25)", "rgba(32, 32, 96, 0.25)", +"hsla(270 50% 25% / 0.25)", "rgba(64, 32, 96, 0.25)", +"hsla(300 50% 25% / 0.25)", "rgba(96, 32, 96, 0.25)", +"hsla(330 50% 25% / 0.25)", "rgba(96, 32, 64, 0.25)", +"hsla(0 62.5% 25% / 0.25)", "rgba(104, 24, 24, 0.25)", +"hsla(30 62.5% 25% / 0.25)", "rgba(104, 64, 24, 0.25)", +"hsla(60 62.5% 25% / 0.25)", "rgba(104, 104, 24, 0.25)", +"hsla(90 62.5% 25% / 0.25)", "rgba(64, 104, 24, 0.25)", +"hsla(120 62.5% 25% / 0.25)", "rgba(24, 104, 24, 0.25)", +"hsla(150 62.5% 25% / 0.25)", "rgba(24, 104, 64, 0.25)", +"hsla(180 62.5% 25% / 0.25)", "rgba(24, 104, 104, 0.25)", +"hsla(210 62.5% 25% / 0.25)", "rgba(24, 64, 104, 0.25)", +"hsla(240 62.5% 25% / 0.25)", "rgba(24, 24, 104, 0.25)", +"hsla(270 62.5% 25% / 0.25)", "rgba(64, 24, 104, 0.25)", +"hsla(300 62.5% 25% / 0.25)", "rgba(104, 24, 104, 0.25)", +"hsla(330 62.5% 25% / 0.25)", "rgba(104, 24, 64, 0.25)", +"hsla(0 75% 25% / 0.25)", "rgba(112, 16, 16, 0.25)", +"hsla(30 75% 25% / 0.25)", "rgba(112, 64, 16, 0.25)", +"hsla(60 75% 25% / 0.25)", "rgba(112, 112, 16, 0.25)", +"hsla(90 75% 25% / 0.25)", "rgba(64, 112, 16, 0.25)", +"hsla(120 75% 25% / 0.25)", "rgba(16, 112, 16, 0.25)", +"hsla(150 75% 25% / 0.25)", "rgba(16, 112, 64, 0.25)", +"hsla(180 75% 25% / 0.25)", "rgba(16, 112, 112, 0.25)", +"hsla(210 75% 25% / 0.25)", "rgba(16, 64, 112, 0.25)", +"hsla(240 75% 25% / 0.25)", "rgba(16, 16, 112, 0.25)", +"hsla(270 75% 25% / 0.25)", "rgba(64, 16, 112, 0.25)", +"hsla(300 75% 25% / 0.25)", "rgba(112, 16, 112, 0.25)", +"hsla(330 75% 25% / 0.25)", "rgba(112, 16, 64, 0.25)", +"hsla(0 87.5% 25% / 0.25)", "rgba(120, 8, 8, 0.25)", +"hsla(30 87.5% 25% / 0.25)", "rgba(120, 64, 8, 0.25)", +"hsla(60 87.5% 25% / 0.25)", "rgba(120, 120, 8, 0.25)", +"hsla(90 87.5% 25% / 0.25)", "rgba(64, 120, 8, 0.25)", +"hsla(120 87.5% 25% / 0.25)", "rgba(8, 120, 8, 0.25)", +"hsla(150 87.5% 25% / 0.25)", "rgba(8, 120, 64, 0.25)", +"hsla(180 87.5% 25% / 0.25)", "rgba(8, 120, 120, 0.25)", +"hsla(210 87.5% 25% / 0.25)", "rgba(8, 64, 120, 0.25)", +"hsla(240 87.5% 25% / 0.25)", "rgba(8, 8, 120, 0.25)", +"hsla(270 87.5% 25% / 0.25)", "rgba(64, 8, 120, 0.25)", +"hsla(300 87.5% 25% / 0.25)", "rgba(120, 8, 120, 0.25)", +"hsla(330 87.5% 25% / 0.25)", "rgba(120, 8, 64, 0.25)", +"hsla(0 100% 25% / 0.25)", "rgba(128, 0, 0, 0.25)", +"hsla(30 100% 25% / 0.25)", "rgba(128, 64, 0, 0.25)", +"hsla(60 100% 25% / 0.25)", "rgba(128, 128, 0, 0.25)", +"hsla(90 100% 25% / 0.25)", "rgba(64, 128, 0, 0.25)", +"hsla(120 100% 25% / 0.25)", "rgba(0, 128, 0, 0.25)", +"hsla(150 100% 25% / 0.25)", "rgba(0, 128, 64, 0.25)", +"hsla(180 100% 25% / 0.25)", "rgba(0, 128, 128, 0.25)", +"hsla(210 100% 25% / 0.25)", "rgba(0, 64, 128, 0.25)", +"hsla(240 100% 25% / 0.25)", "rgba(0, 0, 128, 0.25)", +"hsla(270 100% 25% / 0.25)", "rgba(64, 0, 128, 0.25)", +"hsla(300 100% 25% / 0.25)", "rgba(128, 0, 128, 0.25)", +"hsla(330 100% 25% / 0.25)", "rgba(128, 0, 64, 0.25)", +"hsla(0 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(30 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(60 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(90 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(120 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(150 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(180 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(210 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(240 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(270 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(300 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(330 0% 37.5% / 0.25)", "rgba(96, 96, 96, 0.25)", +"hsla(0 12.5% 37.5% / 0.25)", "rgba(108, 84, 84, 0.25)", +"hsla(30 12.5% 37.5% / 0.25)", "rgba(108, 96, 84, 0.25)", +"hsla(60 12.5% 37.5% / 0.25)", "rgba(108, 108, 84, 0.25)", +"hsla(90 12.5% 37.5% / 0.25)", "rgba(96, 108, 84, 0.25)", +"hsla(120 12.5% 37.5% / 0.25)", "rgba(84, 108, 84, 0.25)", +"hsla(150 12.5% 37.5% / 0.25)", "rgba(84, 108, 96, 0.25)", +"hsla(180 12.5% 37.5% / 0.25)", "rgba(84, 108, 108, 0.25)", +"hsla(210 12.5% 37.5% / 0.25)", "rgba(84, 96, 108, 0.25)", +"hsla(240 12.5% 37.5% / 0.25)", "rgba(84, 84, 108, 0.25)", +"hsla(270 12.5% 37.5% / 0.25)", "rgba(96, 84, 108, 0.25)", +"hsla(300 12.5% 37.5% / 0.25)", "rgba(108, 84, 108, 0.25)", +"hsla(330 12.5% 37.5% / 0.25)", "rgba(108, 84, 96, 0.25)", +"hsla(0 25% 37.5% / 0.25)", "rgba(120, 72, 72, 0.25)", +"hsla(30 25% 37.5% / 0.25)", "rgba(120, 96, 72, 0.25)", +"hsla(60 25% 37.5% / 0.25)", "rgba(120, 120, 72, 0.25)", +"hsla(90 25% 37.5% / 0.25)", "rgba(96, 120, 72, 0.25)", +"hsla(120 25% 37.5% / 0.25)", "rgba(72, 120, 72, 0.25)", +"hsla(150 25% 37.5% / 0.25)", "rgba(72, 120, 96, 0.25)", +"hsla(180 25% 37.5% / 0.25)", "rgba(72, 120, 120, 0.25)", +"hsla(210 25% 37.5% / 0.25)", "rgba(72, 96, 120, 0.25)", +"hsla(240 25% 37.5% / 0.25)", "rgba(72, 72, 120, 0.25)", +"hsla(270 25% 37.5% / 0.25)", "rgba(96, 72, 120, 0.25)", +"hsla(300 25% 37.5% / 0.25)", "rgba(120, 72, 120, 0.25)", +"hsla(330 25% 37.5% / 0.25)", "rgba(120, 72, 96, 0.25)", +"hsla(0 37.5% 37.5% / 0.25)", "rgba(131, 60, 60, 0.25)", +"hsla(30 37.5% 37.5% / 0.25)", "rgba(131, 96, 60, 0.25)", +"hsla(60 37.5% 37.5% / 0.25)", "rgba(131, 131, 60, 0.25)", +"hsla(90 37.5% 37.5% / 0.25)", "rgba(96, 131, 60, 0.25)", +"hsla(120 37.5% 37.5% / 0.25)", "rgba(60, 131, 60, 0.25)", +"hsla(150 37.5% 37.5% / 0.25)", "rgba(60, 131, 96, 0.25)", +"hsla(180 37.5% 37.5% / 0.25)", "rgba(60, 131, 131, 0.25)", +"hsla(210 37.5% 37.5% / 0.25)", "rgba(60, 96, 131, 0.25)", +"hsla(240 37.5% 37.5% / 0.25)", "rgba(60, 60, 131, 0.25)", +"hsla(270 37.5% 37.5% / 0.25)", "rgba(96, 60, 131, 0.25)", +"hsla(300 37.5% 37.5% / 0.25)", "rgba(131, 60, 131, 0.25)", +"hsla(330 37.5% 37.5% / 0.25)", "rgba(131, 60, 96, 0.25)", +"hsla(0 50% 37.5% / 0.25)", "rgba(143, 48, 48, 0.25)", +"hsla(30 50% 37.5% / 0.25)", "rgba(143, 96, 48, 0.25)", +"hsla(60 50% 37.5% / 0.25)", "rgba(143, 143, 48, 0.25)", +"hsla(90 50% 37.5% / 0.25)", "rgba(96, 143, 48, 0.25)", +"hsla(120 50% 37.5% / 0.25)", "rgba(48, 143, 48, 0.25)", +"hsla(150 50% 37.5% / 0.25)", "rgba(48, 143, 96, 0.25)", +"hsla(180 50% 37.5% / 0.25)", "rgba(48, 143, 143, 0.25)", +"hsla(210 50% 37.5% / 0.25)", "rgba(48, 96, 143, 0.25)", +"hsla(240 50% 37.5% / 0.25)", "rgba(48, 48, 143, 0.25)", +"hsla(270 50% 37.5% / 0.25)", "rgba(96, 48, 143, 0.25)", +"hsla(300 50% 37.5% / 0.25)", "rgba(143, 48, 143, 0.25)", +"hsla(330 50% 37.5% / 0.25)", "rgba(143, 48, 96, 0.25)", +"hsla(0 62.5% 37.5% / 0.25)", "rgba(155, 36, 36, 0.25)", +"hsla(30 62.5% 37.5% / 0.25)", "rgba(155, 96, 36, 0.25)", +"hsla(60 62.5% 37.5% / 0.25)", "rgba(155, 155, 36, 0.25)", +"hsla(90 62.5% 37.5% / 0.25)", "rgba(96, 155, 36, 0.25)", +"hsla(120 62.5% 37.5% / 0.25)", "rgba(36, 155, 36, 0.25)", +"hsla(150 62.5% 37.5% / 0.25)", "rgba(36, 155, 96, 0.25)", +"hsla(180 62.5% 37.5% / 0.25)", "rgba(36, 155, 155, 0.25)", +"hsla(210 62.5% 37.5% / 0.25)", "rgba(36, 96, 155, 0.25)", +"hsla(240 62.5% 37.5% / 0.25)", "rgba(36, 36, 155, 0.25)", +"hsla(270 62.5% 37.5% / 0.25)", "rgba(96, 36, 155, 0.25)", +"hsla(300 62.5% 37.5% / 0.25)", "rgba(155, 36, 155, 0.25)", +"hsla(330 62.5% 37.5% / 0.25)", "rgba(155, 36, 96, 0.25)", +"hsla(0 75% 37.5% / 0.25)", "rgba(167, 24, 24, 0.25)", +"hsla(30 75% 37.5% / 0.25)", "rgba(167, 96, 24, 0.25)", +"hsla(60 75% 37.5% / 0.25)", "rgba(167, 167, 24, 0.25)", +"hsla(90 75% 37.5% / 0.25)", "rgba(96, 167, 24, 0.25)", +"hsla(120 75% 37.5% / 0.25)", "rgba(24, 167, 24, 0.25)", +"hsla(150 75% 37.5% / 0.25)", "rgba(24, 167, 96, 0.25)", +"hsla(180 75% 37.5% / 0.25)", "rgba(24, 167, 167, 0.25)", +"hsla(210 75% 37.5% / 0.25)", "rgba(24, 96, 167, 0.25)", +"hsla(240 75% 37.5% / 0.25)", "rgba(24, 24, 167, 0.25)", +"hsla(270 75% 37.5% / 0.25)", "rgba(96, 24, 167, 0.25)", +"hsla(300 75% 37.5% / 0.25)", "rgba(167, 24, 167, 0.25)", +"hsla(330 75% 37.5% / 0.25)", "rgba(167, 24, 96, 0.25)", +"hsla(0 87.5% 37.5% / 0.25)", "rgba(179, 12, 12, 0.25)", +"hsla(30 87.5% 37.5% / 0.25)", "rgba(179, 96, 12, 0.25)", +"hsla(60 87.5% 37.5% / 0.25)", "rgba(179, 179, 12, 0.25)", +"hsla(90 87.5% 37.5% / 0.25)", "rgba(96, 179, 12, 0.25)", +"hsla(120 87.5% 37.5% / 0.25)", "rgba(12, 179, 12, 0.25)", +"hsla(150 87.5% 37.5% / 0.25)", "rgba(12, 179, 96, 0.25)", +"hsla(180 87.5% 37.5% / 0.25)", "rgba(12, 179, 179, 0.25)", +"hsla(210 87.5% 37.5% / 0.25)", "rgba(12, 96, 179, 0.25)", +"hsla(240 87.5% 37.5% / 0.25)", "rgba(12, 12, 179, 0.25)", +"hsla(270 87.5% 37.5% / 0.25)", "rgba(96, 12, 179, 0.25)", +"hsla(300 87.5% 37.5% / 0.25)", "rgba(179, 12, 179, 0.25)", +"hsla(330 87.5% 37.5% / 0.25)", "rgba(179, 12, 96, 0.25)", +"hsla(0 100% 37.5% / 0.25)", "rgba(191, 0, 0, 0.25)", +"hsla(30 100% 37.5% / 0.25)", "rgba(191, 96, 0, 0.25)", +"hsla(60 100% 37.5% / 0.25)", "rgba(191, 191, 0, 0.25)", +"hsla(90 100% 37.5% / 0.25)", "rgba(96, 191, 0, 0.25)", +"hsla(120 100% 37.5% / 0.25)", "rgba(0, 191, 0, 0.25)", +"hsla(150 100% 37.5% / 0.25)", "rgba(0, 191, 96, 0.25)", +"hsla(180 100% 37.5% / 0.25)", "rgba(0, 191, 191, 0.25)", +"hsla(210 100% 37.5% / 0.25)", "rgba(0, 96, 191, 0.25)", +"hsla(240 100% 37.5% / 0.25)", "rgba(0, 0, 191, 0.25)", +"hsla(270 100% 37.5% / 0.25)", "rgba(96, 0, 191, 0.25)", +"hsla(300 100% 37.5% / 0.25)", "rgba(191, 0, 191, 0.25)", +"hsla(330 100% 37.5% / 0.25)", "rgba(191, 0, 96, 0.25)", +"hsla(0 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(30 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(60 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(90 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(120 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(150 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(180 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(210 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(240 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(270 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(300 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(330 0% 50% / 0.25)", "rgba(128, 128, 128, 0.25)", +"hsla(0 12.5% 50% / 0.25)", "rgba(143, 112, 112, 0.25)", +"hsla(30 12.5% 50% / 0.25)", "rgba(143, 128, 112, 0.25)", +"hsla(60 12.5% 50% / 0.25)", "rgba(143, 143, 112, 0.25)", +"hsla(90 12.5% 50% / 0.25)", "rgba(128, 143, 112, 0.25)", +"hsla(120 12.5% 50% / 0.25)", "rgba(112, 143, 112, 0.25)", +"hsla(150 12.5% 50% / 0.25)", "rgba(112, 143, 128, 0.25)", +"hsla(180 12.5% 50% / 0.25)", "rgba(112, 143, 143, 0.25)", +"hsla(210 12.5% 50% / 0.25)", "rgba(112, 128, 143, 0.25)", +"hsla(240 12.5% 50% / 0.25)", "rgba(112, 112, 143, 0.25)", +"hsla(270 12.5% 50% / 0.25)", "rgba(128, 112, 143, 0.25)", +"hsla(300 12.5% 50% / 0.25)", "rgba(143, 112, 143, 0.25)", +"hsla(330 12.5% 50% / 0.25)", "rgba(143, 112, 128, 0.25)", +"hsla(0 25% 50% / 0.25)", "rgba(159, 96, 96, 0.25)", +"hsla(30 25% 50% / 0.25)", "rgba(159, 128, 96, 0.25)", +"hsla(60 25% 50% / 0.25)", "rgba(159, 159, 96, 0.25)", +"hsla(90 25% 50% / 0.25)", "rgba(128, 159, 96, 0.25)", +"hsla(120 25% 50% / 0.25)", "rgba(96, 159, 96, 0.25)", +"hsla(150 25% 50% / 0.25)", "rgba(96, 159, 128, 0.25)", +"hsla(180 25% 50% / 0.25)", "rgba(96, 159, 159, 0.25)", +"hsla(210 25% 50% / 0.25)", "rgba(96, 128, 159, 0.25)", +"hsla(240 25% 50% / 0.25)", "rgba(96, 96, 159, 0.25)", +"hsla(270 25% 50% / 0.25)", "rgba(128, 96, 159, 0.25)", +"hsla(300 25% 50% / 0.25)", "rgba(159, 96, 159, 0.25)", +"hsla(330 25% 50% / 0.25)", "rgba(159, 96, 128, 0.25)", +"hsla(0 37.5% 50% / 0.25)", "rgba(175, 80, 80, 0.25)", +"hsla(30 37.5% 50% / 0.25)", "rgba(175, 128, 80, 0.25)", +"hsla(60 37.5% 50% / 0.25)", "rgba(175, 175, 80, 0.25)", +"hsla(90 37.5% 50% / 0.25)", "rgba(128, 175, 80, 0.25)", +"hsla(120 37.5% 50% / 0.25)", "rgba(80, 175, 80, 0.25)", +"hsla(150 37.5% 50% / 0.25)", "rgba(80, 175, 128, 0.25)", +"hsla(180 37.5% 50% / 0.25)", "rgba(80, 175, 175, 0.25)", +"hsla(210 37.5% 50% / 0.25)", "rgba(80, 128, 175, 0.25)", +"hsla(240 37.5% 50% / 0.25)", "rgba(80, 80, 175, 0.25)", +"hsla(270 37.5% 50% / 0.25)", "rgba(128, 80, 175, 0.25)", +"hsla(300 37.5% 50% / 0.25)", "rgba(175, 80, 175, 0.25)", +"hsla(330 37.5% 50% / 0.25)", "rgba(175, 80, 128, 0.25)", +"hsla(0 50% 50% / 0.25)", "rgba(191, 64, 64, 0.25)", +"hsla(30 50% 50% / 0.25)", "rgba(191, 128, 64, 0.25)", +"hsla(60 50% 50% / 0.25)", "rgba(191, 191, 64, 0.25)", +"hsla(90 50% 50% / 0.25)", "rgba(128, 191, 64, 0.25)", +"hsla(120 50% 50% / 0.25)", "rgba(64, 191, 64, 0.25)", +"hsla(150 50% 50% / 0.25)", "rgba(64, 191, 128, 0.25)", +"hsla(180 50% 50% / 0.25)", "rgba(64, 191, 191, 0.25)", +"hsla(210 50% 50% / 0.25)", "rgba(64, 128, 191, 0.25)", +"hsla(240 50% 50% / 0.25)", "rgba(64, 64, 191, 0.25)", +"hsla(270 50% 50% / 0.25)", "rgba(128, 64, 191, 0.25)", +"hsla(300 50% 50% / 0.25)", "rgba(191, 64, 191, 0.25)", +"hsla(330 50% 50% / 0.25)", "rgba(191, 64, 128, 0.25)", +"hsla(0 62.5% 50% / 0.25)", "rgba(207, 48, 48, 0.25)", +"hsla(30 62.5% 50% / 0.25)", "rgba(207, 128, 48, 0.25)", +"hsla(60 62.5% 50% / 0.25)", "rgba(207, 207, 48, 0.25)", +"hsla(90 62.5% 50% / 0.25)", "rgba(128, 207, 48, 0.25)", +"hsla(120 62.5% 50% / 0.25)", "rgba(48, 207, 48, 0.25)", +"hsla(150 62.5% 50% / 0.25)", "rgba(48, 207, 128, 0.25)", +"hsla(180 62.5% 50% / 0.25)", "rgba(48, 207, 207, 0.25)", +"hsla(210 62.5% 50% / 0.25)", "rgba(48, 128, 207, 0.25)", +"hsla(240 62.5% 50% / 0.25)", "rgba(48, 48, 207, 0.25)", +"hsla(270 62.5% 50% / 0.25)", "rgba(128, 48, 207, 0.25)", +"hsla(300 62.5% 50% / 0.25)", "rgba(207, 48, 207, 0.25)", +"hsla(330 62.5% 50% / 0.25)", "rgba(207, 48, 128, 0.25)", +"hsla(0 75% 50% / 0.25)", "rgba(223, 32, 32, 0.25)", +"hsla(30 75% 50% / 0.25)", "rgba(223, 128, 32, 0.25)", +"hsla(60 75% 50% / 0.25)", "rgba(223, 223, 32, 0.25)", +"hsla(90 75% 50% / 0.25)", "rgba(128, 223, 32, 0.25)", +"hsla(120 75% 50% / 0.25)", "rgba(32, 223, 32, 0.25)", +"hsla(150 75% 50% / 0.25)", "rgba(32, 223, 128, 0.25)", +"hsla(180 75% 50% / 0.25)", "rgba(32, 223, 223, 0.25)", +"hsla(210 75% 50% / 0.25)", "rgba(32, 128, 223, 0.25)", +"hsla(240 75% 50% / 0.25)", "rgba(32, 32, 223, 0.25)", +"hsla(270 75% 50% / 0.25)", "rgba(128, 32, 223, 0.25)", +"hsla(300 75% 50% / 0.25)", "rgba(223, 32, 223, 0.25)", +"hsla(330 75% 50% / 0.25)", "rgba(223, 32, 128, 0.25)", +"hsla(0 87.5% 50% / 0.25)", "rgba(239, 16, 16, 0.25)", +"hsla(30 87.5% 50% / 0.25)", "rgba(239, 128, 16, 0.25)", +"hsla(60 87.5% 50% / 0.25)", "rgba(239, 239, 16, 0.25)", +"hsla(90 87.5% 50% / 0.25)", "rgba(128, 239, 16, 0.25)", +"hsla(120 87.5% 50% / 0.25)", "rgba(16, 239, 16, 0.25)", +"hsla(150 87.5% 50% / 0.25)", "rgba(16, 239, 128, 0.25)", +"hsla(180 87.5% 50% / 0.25)", "rgba(16, 239, 239, 0.25)", +"hsla(210 87.5% 50% / 0.25)", "rgba(16, 128, 239, 0.25)", +"hsla(240 87.5% 50% / 0.25)", "rgba(16, 16, 239, 0.25)", +"hsla(270 87.5% 50% / 0.25)", "rgba(128, 16, 239, 0.25)", +"hsla(300 87.5% 50% / 0.25)", "rgba(239, 16, 239, 0.25)", +"hsla(330 87.5% 50% / 0.25)", "rgba(239, 16, 128, 0.25)", +"hsla(0 100% 50% / 0.25)", "rgba(255, 0, 0, 0.25)", +"hsla(30 100% 50% / 0.25)", "rgba(255, 128, 0, 0.25)", +"hsla(60 100% 50% / 0.25)", "rgba(255, 255, 0, 0.25)", +"hsla(90 100% 50% / 0.25)", "rgba(128, 255, 0, 0.25)", +"hsla(120 100% 50% / 0.25)", "rgba(0, 255, 0, 0.25)", +"hsla(150 100% 50% / 0.25)", "rgba(0, 255, 128, 0.25)", +"hsla(180 100% 50% / 0.25)", "rgba(0, 255, 255, 0.25)", +"hsla(210 100% 50% / 0.25)", "rgba(0, 128, 255, 0.25)", +"hsla(240 100% 50% / 0.25)", "rgba(0, 0, 255, 0.25)", +"hsla(270 100% 50% / 0.25)", "rgba(128, 0, 255, 0.25)", +"hsla(300 100% 50% / 0.25)", "rgba(255, 0, 255, 0.25)", +"hsla(330 100% 50% / 0.25)", "rgba(255, 0, 128, 0.25)", +"hsla(0 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(30 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(60 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(90 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(120 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(150 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(180 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(210 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(240 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(270 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(300 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(330 0% 62.5% / 0.25)", "rgba(159, 159, 159, 0.25)", +"hsla(0 12.5% 62.5% / 0.25)", "rgba(171, 147, 147, 0.25)", +"hsla(30 12.5% 62.5% / 0.25)", "rgba(171, 159, 147, 0.25)", +"hsla(60 12.5% 62.5% / 0.25)", "rgba(171, 171, 147, 0.25)", +"hsla(90 12.5% 62.5% / 0.25)", "rgba(159, 171, 147, 0.25)", +"hsla(120 12.5% 62.5% / 0.25)", "rgba(147, 171, 147, 0.25)", +"hsla(150 12.5% 62.5% / 0.25)", "rgba(147, 171, 159, 0.25)", +"hsla(180 12.5% 62.5% / 0.25)", "rgba(147, 171, 171, 0.25)", +"hsla(210 12.5% 62.5% / 0.25)", "rgba(147, 159, 171, 0.25)", +"hsla(240 12.5% 62.5% / 0.25)", "rgba(147, 147, 171, 0.25)", +"hsla(270 12.5% 62.5% / 0.25)", "rgba(159, 147, 171, 0.25)", +"hsla(300 12.5% 62.5% / 0.25)", "rgba(171, 147, 171, 0.25)", +"hsla(330 12.5% 62.5% / 0.25)", "rgba(171, 147, 159, 0.25)", +"hsla(0 25% 62.5% / 0.25)", "rgba(183, 135, 135, 0.25)", +"hsla(30 25% 62.5% / 0.25)", "rgba(183, 159, 135, 0.25)", +"hsla(60 25% 62.5% / 0.25)", "rgba(183, 183, 135, 0.25)", +"hsla(90 25% 62.5% / 0.25)", "rgba(159, 183, 135, 0.25)", +"hsla(120 25% 62.5% / 0.25)", "rgba(135, 183, 135, 0.25)", +"hsla(150 25% 62.5% / 0.25)", "rgba(135, 183, 159, 0.25)", +"hsla(180 25% 62.5% / 0.25)", "rgba(135, 183, 183, 0.25)", +"hsla(210 25% 62.5% / 0.25)", "rgba(135, 159, 183, 0.25)", +"hsla(240 25% 62.5% / 0.25)", "rgba(135, 135, 183, 0.25)", +"hsla(270 25% 62.5% / 0.25)", "rgba(159, 135, 183, 0.25)", +"hsla(300 25% 62.5% / 0.25)", "rgba(183, 135, 183, 0.25)", +"hsla(330 25% 62.5% / 0.25)", "rgba(183, 135, 159, 0.25)", +"hsla(0 37.5% 62.5% / 0.25)", "rgba(195, 124, 124, 0.25)", +"hsla(30 37.5% 62.5% / 0.25)", "rgba(195, 159, 124, 0.25)", +"hsla(60 37.5% 62.5% / 0.25)", "rgba(195, 195, 124, 0.25)", +"hsla(90 37.5% 62.5% / 0.25)", "rgba(159, 195, 124, 0.25)", +"hsla(120 37.5% 62.5% / 0.25)", "rgba(124, 195, 124, 0.25)", +"hsla(150 37.5% 62.5% / 0.25)", "rgba(124, 195, 159, 0.25)", +"hsla(180 37.5% 62.5% / 0.25)", "rgba(124, 195, 195, 0.25)", +"hsla(210 37.5% 62.5% / 0.25)", "rgba(124, 159, 195, 0.25)", +"hsla(240 37.5% 62.5% / 0.25)", "rgba(124, 124, 195, 0.25)", +"hsla(270 37.5% 62.5% / 0.25)", "rgba(159, 124, 195, 0.25)", +"hsla(300 37.5% 62.5% / 0.25)", "rgba(195, 124, 195, 0.25)", +"hsla(330 37.5% 62.5% / 0.25)", "rgba(195, 124, 159, 0.25)", +"hsla(0 50% 62.5% / 0.25)", "rgba(207, 112, 112, 0.25)", +"hsla(30 50% 62.5% / 0.25)", "rgba(207, 159, 112, 0.25)", +"hsla(60 50% 62.5% / 0.25)", "rgba(207, 207, 112, 0.25)", +"hsla(90 50% 62.5% / 0.25)", "rgba(159, 207, 112, 0.25)", +"hsla(120 50% 62.5% / 0.25)", "rgba(112, 207, 112, 0.25)", +"hsla(150 50% 62.5% / 0.25)", "rgba(112, 207, 159, 0.25)", +"hsla(180 50% 62.5% / 0.25)", "rgba(112, 207, 207, 0.25)", +"hsla(210 50% 62.5% / 0.25)", "rgba(112, 159, 207, 0.25)", +"hsla(240 50% 62.5% / 0.25)", "rgba(112, 112, 207, 0.25)", +"hsla(270 50% 62.5% / 0.25)", "rgba(159, 112, 207, 0.25)", +"hsla(300 50% 62.5% / 0.25)", "rgba(207, 112, 207, 0.25)", +"hsla(330 50% 62.5% / 0.25)", "rgba(207, 112, 159, 0.25)", +"hsla(0 62.5% 62.5% / 0.25)", "rgba(219, 100, 100, 0.25)", +"hsla(30 62.5% 62.5% / 0.25)", "rgba(219, 159, 100, 0.25)", +"hsla(60 62.5% 62.5% / 0.25)", "rgba(219, 219, 100, 0.25)", +"hsla(90 62.5% 62.5% / 0.25)", "rgba(159, 219, 100, 0.25)", +"hsla(120 62.5% 62.5% / 0.25)", "rgba(100, 219, 100, 0.25)", +"hsla(150 62.5% 62.5% / 0.25)", "rgba(100, 219, 159, 0.25)", +"hsla(180 62.5% 62.5% / 0.25)", "rgba(100, 219, 219, 0.25)", +"hsla(210 62.5% 62.5% / 0.25)", "rgba(100, 159, 219, 0.25)", +"hsla(240 62.5% 62.5% / 0.25)", "rgba(100, 100, 219, 0.25)", +"hsla(270 62.5% 62.5% / 0.25)", "rgba(159, 100, 219, 0.25)", +"hsla(300 62.5% 62.5% / 0.25)", "rgba(219, 100, 219, 0.25)", +"hsla(330 62.5% 62.5% / 0.25)", "rgba(219, 100, 159, 0.25)", +"hsla(0 75% 62.5% / 0.25)", "rgba(231, 88, 88, 0.25)", +"hsla(30 75% 62.5% / 0.25)", "rgba(231, 159, 88, 0.25)", +"hsla(60 75% 62.5% / 0.25)", "rgba(231, 231, 88, 0.25)", +"hsla(90 75% 62.5% / 0.25)", "rgba(159, 231, 88, 0.25)", +"hsla(120 75% 62.5% / 0.25)", "rgba(88, 231, 88, 0.25)", +"hsla(150 75% 62.5% / 0.25)", "rgba(88, 231, 159, 0.25)", +"hsla(180 75% 62.5% / 0.25)", "rgba(88, 231, 231, 0.25)", +"hsla(210 75% 62.5% / 0.25)", "rgba(88, 159, 231, 0.25)", +"hsla(240 75% 62.5% / 0.25)", "rgba(88, 88, 231, 0.25)", +"hsla(270 75% 62.5% / 0.25)", "rgba(159, 88, 231, 0.25)", +"hsla(300 75% 62.5% / 0.25)", "rgba(231, 88, 231, 0.25)", +"hsla(330 75% 62.5% / 0.25)", "rgba(231, 88, 159, 0.25)", +"hsla(0 87.5% 62.5% / 0.25)", "rgba(243, 76, 76, 0.25)", +"hsla(30 87.5% 62.5% / 0.25)", "rgba(243, 159, 76, 0.25)", +"hsla(60 87.5% 62.5% / 0.25)", "rgba(243, 243, 76, 0.25)", +"hsla(90 87.5% 62.5% / 0.25)", "rgba(159, 243, 76, 0.25)", +"hsla(120 87.5% 62.5% / 0.25)", "rgba(76, 243, 76, 0.25)", +"hsla(150 87.5% 62.5% / 0.25)", "rgba(76, 243, 159, 0.25)", +"hsla(180 87.5% 62.5% / 0.25)", "rgba(76, 243, 243, 0.25)", +"hsla(210 87.5% 62.5% / 0.25)", "rgba(76, 159, 243, 0.25)", +"hsla(240 87.5% 62.5% / 0.25)", "rgba(76, 76, 243, 0.25)", +"hsla(270 87.5% 62.5% / 0.25)", "rgba(159, 76, 243, 0.25)", +"hsla(300 87.5% 62.5% / 0.25)", "rgba(243, 76, 243, 0.25)", +"hsla(330 87.5% 62.5% / 0.25)", "rgba(243, 76, 159, 0.25)", +"hsla(0 100% 62.5% / 0.25)", "rgba(255, 64, 64, 0.25)", +"hsla(30 100% 62.5% / 0.25)", "rgba(255, 159, 64, 0.25)", +"hsla(60 100% 62.5% / 0.25)", "rgba(255, 255, 64, 0.25)", +"hsla(90 100% 62.5% / 0.25)", "rgba(159, 255, 64, 0.25)", +"hsla(120 100% 62.5% / 0.25)", "rgba(64, 255, 64, 0.25)", +"hsla(150 100% 62.5% / 0.25)", "rgba(64, 255, 159, 0.25)", +"hsla(180 100% 62.5% / 0.25)", "rgba(64, 255, 255, 0.25)", +"hsla(210 100% 62.5% / 0.25)", "rgba(64, 159, 255, 0.25)", +"hsla(240 100% 62.5% / 0.25)", "rgba(64, 64, 255, 0.25)", +"hsla(270 100% 62.5% / 0.25)", "rgba(159, 64, 255, 0.25)", +"hsla(300 100% 62.5% / 0.25)", "rgba(255, 64, 255, 0.25)", +"hsla(330 100% 62.5% / 0.25)", "rgba(255, 64, 159, 0.25)", +"hsla(0 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(30 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(60 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(90 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(120 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(150 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(180 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(210 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(240 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(270 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(300 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(330 0% 75% / 0.25)", "rgba(191, 191, 191, 0.25)", +"hsla(0 12.5% 75% / 0.25)", "rgba(199, 183, 183, 0.25)", +"hsla(30 12.5% 75% / 0.25)", "rgba(199, 191, 183, 0.25)", +"hsla(60 12.5% 75% / 0.25)", "rgba(199, 199, 183, 0.25)", +"hsla(90 12.5% 75% / 0.25)", "rgba(191, 199, 183, 0.25)", +"hsla(120 12.5% 75% / 0.25)", "rgba(183, 199, 183, 0.25)", +"hsla(150 12.5% 75% / 0.25)", "rgba(183, 199, 191, 0.25)", +"hsla(180 12.5% 75% / 0.25)", "rgba(183, 199, 199, 0.25)", +"hsla(210 12.5% 75% / 0.25)", "rgba(183, 191, 199, 0.25)", +"hsla(240 12.5% 75% / 0.25)", "rgba(183, 183, 199, 0.25)", +"hsla(270 12.5% 75% / 0.25)", "rgba(191, 183, 199, 0.25)", +"hsla(300 12.5% 75% / 0.25)", "rgba(199, 183, 199, 0.25)", +"hsla(330 12.5% 75% / 0.25)", "rgba(199, 183, 191, 0.25)", +"hsla(0 25% 75% / 0.25)", "rgba(207, 175, 175, 0.25)", +"hsla(30 25% 75% / 0.25)", "rgba(207, 191, 175, 0.25)", +"hsla(60 25% 75% / 0.25)", "rgba(207, 207, 175, 0.25)", +"hsla(90 25% 75% / 0.25)", "rgba(191, 207, 175, 0.25)", +"hsla(120 25% 75% / 0.25)", "rgba(175, 207, 175, 0.25)", +"hsla(150 25% 75% / 0.25)", "rgba(175, 207, 191, 0.25)", +"hsla(180 25% 75% / 0.25)", "rgba(175, 207, 207, 0.25)", +"hsla(210 25% 75% / 0.25)", "rgba(175, 191, 207, 0.25)", +"hsla(240 25% 75% / 0.25)", "rgba(175, 175, 207, 0.25)", +"hsla(270 25% 75% / 0.25)", "rgba(191, 175, 207, 0.25)", +"hsla(300 25% 75% / 0.25)", "rgba(207, 175, 207, 0.25)", +"hsla(330 25% 75% / 0.25)", "rgba(207, 175, 191, 0.25)", +"hsla(0 37.5% 75% / 0.25)", "rgba(215, 167, 167, 0.25)", +"hsla(30 37.5% 75% / 0.25)", "rgba(215, 191, 167, 0.25)", +"hsla(60 37.5% 75% / 0.25)", "rgba(215, 215, 167, 0.25)", +"hsla(90 37.5% 75% / 0.25)", "rgba(191, 215, 167, 0.25)", +"hsla(120 37.5% 75% / 0.25)", "rgba(167, 215, 167, 0.25)", +"hsla(150 37.5% 75% / 0.25)", "rgba(167, 215, 191, 0.25)", +"hsla(180 37.5% 75% / 0.25)", "rgba(167, 215, 215, 0.25)", +"hsla(210 37.5% 75% / 0.25)", "rgba(167, 191, 215, 0.25)", +"hsla(240 37.5% 75% / 0.25)", "rgba(167, 167, 215, 0.25)", +"hsla(270 37.5% 75% / 0.25)", "rgba(191, 167, 215, 0.25)", +"hsla(300 37.5% 75% / 0.25)", "rgba(215, 167, 215, 0.25)", +"hsla(330 37.5% 75% / 0.25)", "rgba(215, 167, 191, 0.25)", +"hsla(0 50% 75% / 0.25)", "rgba(223, 159, 159, 0.25)", +"hsla(30 50% 75% / 0.25)", "rgba(223, 191, 159, 0.25)", +"hsla(60 50% 75% / 0.25)", "rgba(223, 223, 159, 0.25)", +"hsla(90 50% 75% / 0.25)", "rgba(191, 223, 159, 0.25)", +"hsla(120 50% 75% / 0.25)", "rgba(159, 223, 159, 0.25)", +"hsla(150 50% 75% / 0.25)", "rgba(159, 223, 191, 0.25)", +"hsla(180 50% 75% / 0.25)", "rgba(159, 223, 223, 0.25)", +"hsla(210 50% 75% / 0.25)", "rgba(159, 191, 223, 0.25)", +"hsla(240 50% 75% / 0.25)", "rgba(159, 159, 223, 0.25)", +"hsla(270 50% 75% / 0.25)", "rgba(191, 159, 223, 0.25)", +"hsla(300 50% 75% / 0.25)", "rgba(223, 159, 223, 0.25)", +"hsla(330 50% 75% / 0.25)", "rgba(223, 159, 191, 0.25)", +"hsla(0 62.5% 75% / 0.25)", "rgba(231, 151, 151, 0.25)", +"hsla(30 62.5% 75% / 0.25)", "rgba(231, 191, 151, 0.25)", +"hsla(60 62.5% 75% / 0.25)", "rgba(231, 231, 151, 0.25)", +"hsla(90 62.5% 75% / 0.25)", "rgba(191, 231, 151, 0.25)", +"hsla(120 62.5% 75% / 0.25)", "rgba(151, 231, 151, 0.25)", +"hsla(150 62.5% 75% / 0.25)", "rgba(151, 231, 191, 0.25)", +"hsla(180 62.5% 75% / 0.25)", "rgba(151, 231, 231, 0.25)", +"hsla(210 62.5% 75% / 0.25)", "rgba(151, 191, 231, 0.25)", +"hsla(240 62.5% 75% / 0.25)", "rgba(151, 151, 231, 0.25)", +"hsla(270 62.5% 75% / 0.25)", "rgba(191, 151, 231, 0.25)", +"hsla(300 62.5% 75% / 0.25)", "rgba(231, 151, 231, 0.25)", +"hsla(330 62.5% 75% / 0.25)", "rgba(231, 151, 191, 0.25)", +"hsla(0 75% 75% / 0.25)", "rgba(239, 143, 143, 0.25)", +"hsla(30 75% 75% / 0.25)", "rgba(239, 191, 143, 0.25)", +"hsla(60 75% 75% / 0.25)", "rgba(239, 239, 143, 0.25)", +"hsla(90 75% 75% / 0.25)", "rgba(191, 239, 143, 0.25)", +"hsla(120 75% 75% / 0.25)", "rgba(143, 239, 143, 0.25)", +"hsla(150 75% 75% / 0.25)", "rgba(143, 239, 191, 0.25)", +"hsla(180 75% 75% / 0.25)", "rgba(143, 239, 239, 0.25)", +"hsla(210 75% 75% / 0.25)", "rgba(143, 191, 239, 0.25)", +"hsla(240 75% 75% / 0.25)", "rgba(143, 143, 239, 0.25)", +"hsla(270 75% 75% / 0.25)", "rgba(191, 143, 239, 0.25)", +"hsla(300 75% 75% / 0.25)", "rgba(239, 143, 239, 0.25)", +"hsla(330 75% 75% / 0.25)", "rgba(239, 143, 191, 0.25)", +"hsla(0 87.5% 75% / 0.25)", "rgba(247, 135, 135, 0.25)", +"hsla(30 87.5% 75% / 0.25)", "rgba(247, 191, 135, 0.25)", +"hsla(60 87.5% 75% / 0.25)", "rgba(247, 247, 135, 0.25)", +"hsla(90 87.5% 75% / 0.25)", "rgba(191, 247, 135, 0.25)", +"hsla(120 87.5% 75% / 0.25)", "rgba(135, 247, 135, 0.25)", +"hsla(150 87.5% 75% / 0.25)", "rgba(135, 247, 191, 0.25)", +"hsla(180 87.5% 75% / 0.25)", "rgba(135, 247, 247, 0.25)", +"hsla(210 87.5% 75% / 0.25)", "rgba(135, 191, 247, 0.25)", +"hsla(240 87.5% 75% / 0.25)", "rgba(135, 135, 247, 0.25)", +"hsla(270 87.5% 75% / 0.25)", "rgba(191, 135, 247, 0.25)", +"hsla(300 87.5% 75% / 0.25)", "rgba(247, 135, 247, 0.25)", +"hsla(330 87.5% 75% / 0.25)", "rgba(247, 135, 191, 0.25)", +"hsla(0 100% 75% / 0.25)", "rgba(255, 128, 128, 0.25)", +"hsla(30 100% 75% / 0.25)", "rgba(255, 191, 128, 0.25)", +"hsla(60 100% 75% / 0.25)", "rgba(255, 255, 128, 0.25)", +"hsla(90 100% 75% / 0.25)", "rgba(191, 255, 128, 0.25)", +"hsla(120 100% 75% / 0.25)", "rgba(128, 255, 128, 0.25)", +"hsla(150 100% 75% / 0.25)", "rgba(128, 255, 191, 0.25)", +"hsla(180 100% 75% / 0.25)", "rgba(128, 255, 255, 0.25)", +"hsla(210 100% 75% / 0.25)", "rgba(128, 191, 255, 0.25)", +"hsla(240 100% 75% / 0.25)", "rgba(128, 128, 255, 0.25)", +"hsla(270 100% 75% / 0.25)", "rgba(191, 128, 255, 0.25)", +"hsla(300 100% 75% / 0.25)", "rgba(255, 128, 255, 0.25)", +"hsla(330 100% 75% / 0.25)", "rgba(255, 128, 191, 0.25)", +"hsla(0 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(30 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(60 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(90 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(120 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(150 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(180 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(210 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(240 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(270 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(300 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(330 0% 87.5% / 0.25)", "rgba(223, 223, 223, 0.25)", +"hsla(0 12.5% 87.5% / 0.25)", "rgba(227, 219, 219, 0.25)", +"hsla(30 12.5% 87.5% / 0.25)", "rgba(227, 223, 219, 0.25)", +"hsla(60 12.5% 87.5% / 0.25)", "rgba(227, 227, 219, 0.25)", +"hsla(90 12.5% 87.5% / 0.25)", "rgba(223, 227, 219, 0.25)", +"hsla(120 12.5% 87.5% / 0.25)", "rgba(219, 227, 219, 0.25)", +"hsla(150 12.5% 87.5% / 0.25)", "rgba(219, 227, 223, 0.25)", +"hsla(180 12.5% 87.5% / 0.25)", "rgba(219, 227, 227, 0.25)", +"hsla(210 12.5% 87.5% / 0.25)", "rgba(219, 223, 227, 0.25)", +"hsla(240 12.5% 87.5% / 0.25)", "rgba(219, 219, 227, 0.25)", +"hsla(270 12.5% 87.5% / 0.25)", "rgba(223, 219, 227, 0.25)", +"hsla(300 12.5% 87.5% / 0.25)", "rgba(227, 219, 227, 0.25)", +"hsla(330 12.5% 87.5% / 0.25)", "rgba(227, 219, 223, 0.25)", +"hsla(0 25% 87.5% / 0.25)", "rgba(231, 215, 215, 0.25)", +"hsla(30 25% 87.5% / 0.25)", "rgba(231, 223, 215, 0.25)", +"hsla(60 25% 87.5% / 0.25)", "rgba(231, 231, 215, 0.25)", +"hsla(90 25% 87.5% / 0.25)", "rgba(223, 231, 215, 0.25)", +"hsla(120 25% 87.5% / 0.25)", "rgba(215, 231, 215, 0.25)", +"hsla(150 25% 87.5% / 0.25)", "rgba(215, 231, 223, 0.25)", +"hsla(180 25% 87.5% / 0.25)", "rgba(215, 231, 231, 0.25)", +"hsla(210 25% 87.5% / 0.25)", "rgba(215, 223, 231, 0.25)", +"hsla(240 25% 87.5% / 0.25)", "rgba(215, 215, 231, 0.25)", +"hsla(270 25% 87.5% / 0.25)", "rgba(223, 215, 231, 0.25)", +"hsla(300 25% 87.5% / 0.25)", "rgba(231, 215, 231, 0.25)", +"hsla(330 25% 87.5% / 0.25)", "rgba(231, 215, 223, 0.25)", +"hsla(0 37.5% 87.5% / 0.25)", "rgba(235, 211, 211, 0.25)", +"hsla(30 37.5% 87.5% / 0.25)", "rgba(235, 223, 211, 0.25)", +"hsla(60 37.5% 87.5% / 0.25)", "rgba(235, 235, 211, 0.25)", +"hsla(90 37.5% 87.5% / 0.25)", "rgba(223, 235, 211, 0.25)", +"hsla(120 37.5% 87.5% / 0.25)", "rgba(211, 235, 211, 0.25)", +"hsla(150 37.5% 87.5% / 0.25)", "rgba(211, 235, 223, 0.25)", +"hsla(180 37.5% 87.5% / 0.25)", "rgba(211, 235, 235, 0.25)", +"hsla(210 37.5% 87.5% / 0.25)", "rgba(211, 223, 235, 0.25)", +"hsla(240 37.5% 87.5% / 0.25)", "rgba(211, 211, 235, 0.25)", +"hsla(270 37.5% 87.5% / 0.25)", "rgba(223, 211, 235, 0.25)", +"hsla(300 37.5% 87.5% / 0.25)", "rgba(235, 211, 235, 0.25)", +"hsla(330 37.5% 87.5% / 0.25)", "rgba(235, 211, 223, 0.25)", +"hsla(0 50% 87.5% / 0.25)", "rgba(239, 207, 207, 0.25)", +"hsla(30 50% 87.5% / 0.25)", "rgba(239, 223, 207, 0.25)", +"hsla(60 50% 87.5% / 0.25)", "rgba(239, 239, 207, 0.25)", +"hsla(90 50% 87.5% / 0.25)", "rgba(223, 239, 207, 0.25)", +"hsla(120 50% 87.5% / 0.25)", "rgba(207, 239, 207, 0.25)", +"hsla(150 50% 87.5% / 0.25)", "rgba(207, 239, 223, 0.25)", +"hsla(180 50% 87.5% / 0.25)", "rgba(207, 239, 239, 0.25)", +"hsla(210 50% 87.5% / 0.25)", "rgba(207, 223, 239, 0.25)", +"hsla(240 50% 87.5% / 0.25)", "rgba(207, 207, 239, 0.25)", +"hsla(270 50% 87.5% / 0.25)", "rgba(223, 207, 239, 0.25)", +"hsla(300 50% 87.5% / 0.25)", "rgba(239, 207, 239, 0.25)", +"hsla(330 50% 87.5% / 0.25)", "rgba(239, 207, 223, 0.25)", +"hsla(0 62.5% 87.5% / 0.25)", "rgba(243, 203, 203, 0.25)", +"hsla(30 62.5% 87.5% / 0.25)", "rgba(243, 223, 203, 0.25)", +"hsla(60 62.5% 87.5% / 0.25)", "rgba(243, 243, 203, 0.25)", +"hsla(90 62.5% 87.5% / 0.25)", "rgba(223, 243, 203, 0.25)", +"hsla(120 62.5% 87.5% / 0.25)", "rgba(203, 243, 203, 0.25)", +"hsla(150 62.5% 87.5% / 0.25)", "rgba(203, 243, 223, 0.25)", +"hsla(180 62.5% 87.5% / 0.25)", "rgba(203, 243, 243, 0.25)", +"hsla(210 62.5% 87.5% / 0.25)", "rgba(203, 223, 243, 0.25)", +"hsla(240 62.5% 87.5% / 0.25)", "rgba(203, 203, 243, 0.25)", +"hsla(270 62.5% 87.5% / 0.25)", "rgba(223, 203, 243, 0.25)", +"hsla(300 62.5% 87.5% / 0.25)", "rgba(243, 203, 243, 0.25)", +"hsla(330 62.5% 87.5% / 0.25)", "rgba(243, 203, 223, 0.25)", +"hsla(0 75% 87.5% / 0.25)", "rgba(247, 199, 199, 0.25)", +"hsla(30 75% 87.5% / 0.25)", "rgba(247, 223, 199, 0.25)", +"hsla(60 75% 87.5% / 0.25)", "rgba(247, 247, 199, 0.25)", +"hsla(90 75% 87.5% / 0.25)", "rgba(223, 247, 199, 0.25)", +"hsla(120 75% 87.5% / 0.25)", "rgba(199, 247, 199, 0.25)", +"hsla(150 75% 87.5% / 0.25)", "rgba(199, 247, 223, 0.25)", +"hsla(180 75% 87.5% / 0.25)", "rgba(199, 247, 247, 0.25)", +"hsla(210 75% 87.5% / 0.25)", "rgba(199, 223, 247, 0.25)", +"hsla(240 75% 87.5% / 0.25)", "rgba(199, 199, 247, 0.25)", +"hsla(270 75% 87.5% / 0.25)", "rgba(223, 199, 247, 0.25)", +"hsla(300 75% 87.5% / 0.25)", "rgba(247, 199, 247, 0.25)", +"hsla(330 75% 87.5% / 0.25)", "rgba(247, 199, 223, 0.25)", +"hsla(0 87.5% 87.5% / 0.25)", "rgba(251, 195, 195, 0.25)", +"hsla(30 87.5% 87.5% / 0.25)", "rgba(251, 223, 195, 0.25)", +"hsla(60 87.5% 87.5% / 0.25)", "rgba(251, 251, 195, 0.25)", +"hsla(90 87.5% 87.5% / 0.25)", "rgba(223, 251, 195, 0.25)", +"hsla(120 87.5% 87.5% / 0.25)", "rgba(195, 251, 195, 0.25)", +"hsla(150 87.5% 87.5% / 0.25)", "rgba(195, 251, 223, 0.25)", +"hsla(180 87.5% 87.5% / 0.25)", "rgba(195, 251, 251, 0.25)", +"hsla(210 87.5% 87.5% / 0.25)", "rgba(195, 223, 251, 0.25)", +"hsla(240 87.5% 87.5% / 0.25)", "rgba(195, 195, 251, 0.25)", +"hsla(270 87.5% 87.5% / 0.25)", "rgba(223, 195, 251, 0.25)", +"hsla(300 87.5% 87.5% / 0.25)", "rgba(251, 195, 251, 0.25)", +"hsla(330 87.5% 87.5% / 0.25)", "rgba(251, 195, 223, 0.25)", +"hsla(0 100% 87.5% / 0.25)", "rgba(255, 191, 191, 0.25)", +"hsla(30 100% 87.5% / 0.25)", "rgba(255, 223, 191, 0.25)", +"hsla(60 100% 87.5% / 0.25)", "rgba(255, 255, 191, 0.25)", +"hsla(90 100% 87.5% / 0.25)", "rgba(223, 255, 191, 0.25)", +"hsla(120 100% 87.5% / 0.25)", "rgba(191, 255, 191, 0.25)", +"hsla(150 100% 87.5% / 0.25)", "rgba(191, 255, 223, 0.25)", +"hsla(180 100% 87.5% / 0.25)", "rgba(191, 255, 255, 0.25)", +"hsla(210 100% 87.5% / 0.25)", "rgba(191, 223, 255, 0.25)", +"hsla(240 100% 87.5% / 0.25)", "rgba(191, 191, 255, 0.25)", +"hsla(270 100% 87.5% / 0.25)", "rgba(223, 191, 255, 0.25)", +"hsla(300 100% 87.5% / 0.25)", "rgba(255, 191, 255, 0.25)", +"hsla(330 100% 87.5% / 0.25)", "rgba(255, 191, 223, 0.25)", +"hsla(0 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 0% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 12.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 25% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 37.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 50% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 62.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 75% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 87.5% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(30 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(60 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(90 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(120 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(150 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(180 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(210 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(240 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(270 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(300 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(330 100% 100% / 0.25)", "rgba(255, 255, 255, 0.25)", +"hsla(0 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 0% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 12.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 25% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 37.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 50% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 62.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 75% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 87.5% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(30 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(60 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(90 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(120 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(150 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(180 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(210 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(240 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(270 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(300 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(330 100% 0% / 0.0)", "rgba(0, 0, 0, 0)", +"hsla(0 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(30 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(60 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(90 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(120 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(150 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(180 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(210 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(240 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(270 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(300 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(330 0% 12.5% / 0.0)", "rgba(32, 32, 32, 0)", +"hsla(0 12.5% 12.5% / 0.0)", "rgba(36, 28, 28, 0)", +"hsla(30 12.5% 12.5% / 0.0)", "rgba(36, 32, 28, 0)", +"hsla(60 12.5% 12.5% / 0.0)", "rgba(36, 36, 28, 0)", +"hsla(90 12.5% 12.5% / 0.0)", "rgba(32, 36, 28, 0)", +"hsla(120 12.5% 12.5% / 0.0)", "rgba(28, 36, 28, 0)", +"hsla(150 12.5% 12.5% / 0.0)", "rgba(28, 36, 32, 0)", +"hsla(180 12.5% 12.5% / 0.0)", "rgba(28, 36, 36, 0)", +"hsla(210 12.5% 12.5% / 0.0)", "rgba(28, 32, 36, 0)", +"hsla(240 12.5% 12.5% / 0.0)", "rgba(28, 28, 36, 0)", +"hsla(270 12.5% 12.5% / 0.0)", "rgba(32, 28, 36, 0)", +"hsla(300 12.5% 12.5% / 0.0)", "rgba(36, 28, 36, 0)", +"hsla(330 12.5% 12.5% / 0.0)", "rgba(36, 28, 32, 0)", +"hsla(0 25% 12.5% / 0.0)", "rgba(40, 24, 24, 0)", +"hsla(30 25% 12.5% / 0.0)", "rgba(40, 32, 24, 0)", +"hsla(60 25% 12.5% / 0.0)", "rgba(40, 40, 24, 0)", +"hsla(90 25% 12.5% / 0.0)", "rgba(32, 40, 24, 0)", +"hsla(120 25% 12.5% / 0.0)", "rgba(24, 40, 24, 0)", +"hsla(150 25% 12.5% / 0.0)", "rgba(24, 40, 32, 0)", +"hsla(180 25% 12.5% / 0.0)", "rgba(24, 40, 40, 0)", +"hsla(210 25% 12.5% / 0.0)", "rgba(24, 32, 40, 0)", +"hsla(240 25% 12.5% / 0.0)", "rgba(24, 24, 40, 0)", +"hsla(270 25% 12.5% / 0.0)", "rgba(32, 24, 40, 0)", +"hsla(300 25% 12.5% / 0.0)", "rgba(40, 24, 40, 0)", +"hsla(330 25% 12.5% / 0.0)", "rgba(40, 24, 32, 0)", +"hsla(0 37.5% 12.5% / 0.0)", "rgba(44, 20, 20, 0)", +"hsla(30 37.5% 12.5% / 0.0)", "rgba(44, 32, 20, 0)", +"hsla(60 37.5% 12.5% / 0.0)", "rgba(44, 44, 20, 0)", +"hsla(90 37.5% 12.5% / 0.0)", "rgba(32, 44, 20, 0)", +"hsla(120 37.5% 12.5% / 0.0)", "rgba(20, 44, 20, 0)", +"hsla(150 37.5% 12.5% / 0.0)", "rgba(20, 44, 32, 0)", +"hsla(180 37.5% 12.5% / 0.0)", "rgba(20, 44, 44, 0)", +"hsla(210 37.5% 12.5% / 0.0)", "rgba(20, 32, 44, 0)", +"hsla(240 37.5% 12.5% / 0.0)", "rgba(20, 20, 44, 0)", +"hsla(270 37.5% 12.5% / 0.0)", "rgba(32, 20, 44, 0)", +"hsla(300 37.5% 12.5% / 0.0)", "rgba(44, 20, 44, 0)", +"hsla(330 37.5% 12.5% / 0.0)", "rgba(44, 20, 32, 0)", +"hsla(0 50% 12.5% / 0.0)", "rgba(48, 16, 16, 0)", +"hsla(30 50% 12.5% / 0.0)", "rgba(48, 32, 16, 0)", +"hsla(60 50% 12.5% / 0.0)", "rgba(48, 48, 16, 0)", +"hsla(90 50% 12.5% / 0.0)", "rgba(32, 48, 16, 0)", +"hsla(120 50% 12.5% / 0.0)", "rgba(16, 48, 16, 0)", +"hsla(150 50% 12.5% / 0.0)", "rgba(16, 48, 32, 0)", +"hsla(180 50% 12.5% / 0.0)", "rgba(16, 48, 48, 0)", +"hsla(210 50% 12.5% / 0.0)", "rgba(16, 32, 48, 0)", +"hsla(240 50% 12.5% / 0.0)", "rgba(16, 16, 48, 0)", +"hsla(270 50% 12.5% / 0.0)", "rgba(32, 16, 48, 0)", +"hsla(300 50% 12.5% / 0.0)", "rgba(48, 16, 48, 0)", +"hsla(330 50% 12.5% / 0.0)", "rgba(48, 16, 32, 0)", +"hsla(0 62.5% 12.5% / 0.0)", "rgba(52, 12, 12, 0)", +"hsla(30 62.5% 12.5% / 0.0)", "rgba(52, 32, 12, 0)", +"hsla(60 62.5% 12.5% / 0.0)", "rgba(52, 52, 12, 0)", +"hsla(90 62.5% 12.5% / 0.0)", "rgba(32, 52, 12, 0)", +"hsla(120 62.5% 12.5% / 0.0)", "rgba(12, 52, 12, 0)", +"hsla(150 62.5% 12.5% / 0.0)", "rgba(12, 52, 32, 0)", +"hsla(180 62.5% 12.5% / 0.0)", "rgba(12, 52, 52, 0)", +"hsla(210 62.5% 12.5% / 0.0)", "rgba(12, 32, 52, 0)", +"hsla(240 62.5% 12.5% / 0.0)", "rgba(12, 12, 52, 0)", +"hsla(270 62.5% 12.5% / 0.0)", "rgba(32, 12, 52, 0)", +"hsla(300 62.5% 12.5% / 0.0)", "rgba(52, 12, 52, 0)", +"hsla(330 62.5% 12.5% / 0.0)", "rgba(52, 12, 32, 0)", +"hsla(0 75% 12.5% / 0.0)", "rgba(56, 8, 8, 0)", +"hsla(30 75% 12.5% / 0.0)", "rgba(56, 32, 8, 0)", +"hsla(60 75% 12.5% / 0.0)", "rgba(56, 56, 8, 0)", +"hsla(90 75% 12.5% / 0.0)", "rgba(32, 56, 8, 0)", +"hsla(120 75% 12.5% / 0.0)", "rgba(8, 56, 8, 0)", +"hsla(150 75% 12.5% / 0.0)", "rgba(8, 56, 32, 0)", +"hsla(180 75% 12.5% / 0.0)", "rgba(8, 56, 56, 0)", +"hsla(210 75% 12.5% / 0.0)", "rgba(8, 32, 56, 0)", +"hsla(240 75% 12.5% / 0.0)", "rgba(8, 8, 56, 0)", +"hsla(270 75% 12.5% / 0.0)", "rgba(32, 8, 56, 0)", +"hsla(300 75% 12.5% / 0.0)", "rgba(56, 8, 56, 0)", +"hsla(330 75% 12.5% / 0.0)", "rgba(56, 8, 32, 0)", +"hsla(0 87.5% 12.5% / 0.0)", "rgba(60, 4, 4, 0)", +"hsla(30 87.5% 12.5% / 0.0)", "rgba(60, 32, 4, 0)", +"hsla(60 87.5% 12.5% / 0.0)", "rgba(60, 60, 4, 0)", +"hsla(90 87.5% 12.5% / 0.0)", "rgba(32, 60, 4, 0)", +"hsla(120 87.5% 12.5% / 0.0)", "rgba(4, 60, 4, 0)", +"hsla(150 87.5% 12.5% / 0.0)", "rgba(4, 60, 32, 0)", +"hsla(180 87.5% 12.5% / 0.0)", "rgba(4, 60, 60, 0)", +"hsla(210 87.5% 12.5% / 0.0)", "rgba(4, 32, 60, 0)", +"hsla(240 87.5% 12.5% / 0.0)", "rgba(4, 4, 60, 0)", +"hsla(270 87.5% 12.5% / 0.0)", "rgba(32, 4, 60, 0)", +"hsla(300 87.5% 12.5% / 0.0)", "rgba(60, 4, 60, 0)", +"hsla(330 87.5% 12.5% / 0.0)", "rgba(60, 4, 32, 0)", +"hsla(0 100% 12.5% / 0.0)", "rgba(64, 0, 0, 0)", +"hsla(30 100% 12.5% / 0.0)", "rgba(64, 32, 0, 0)", +"hsla(60 100% 12.5% / 0.0)", "rgba(64, 64, 0, 0)", +"hsla(90 100% 12.5% / 0.0)", "rgba(32, 64, 0, 0)", +"hsla(120 100% 12.5% / 0.0)", "rgba(0, 64, 0, 0)", +"hsla(150 100% 12.5% / 0.0)", "rgba(0, 64, 32, 0)", +"hsla(180 100% 12.5% / 0.0)", "rgba(0, 64, 64, 0)", +"hsla(210 100% 12.5% / 0.0)", "rgba(0, 32, 64, 0)", +"hsla(240 100% 12.5% / 0.0)", "rgba(0, 0, 64, 0)", +"hsla(270 100% 12.5% / 0.0)", "rgba(32, 0, 64, 0)", +"hsla(300 100% 12.5% / 0.0)", "rgba(64, 0, 64, 0)", +"hsla(330 100% 12.5% / 0.0)", "rgba(64, 0, 32, 0)", +"hsla(0 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(30 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(60 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(90 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(120 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(150 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(180 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(210 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(240 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(270 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(300 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(330 0% 25% / 0.0)", "rgba(64, 64, 64, 0)", +"hsla(0 12.5% 25% / 0.0)", "rgba(72, 56, 56, 0)", +"hsla(30 12.5% 25% / 0.0)", "rgba(72, 64, 56, 0)", +"hsla(60 12.5% 25% / 0.0)", "rgba(72, 72, 56, 0)", +"hsla(90 12.5% 25% / 0.0)", "rgba(64, 72, 56, 0)", +"hsla(120 12.5% 25% / 0.0)", "rgba(56, 72, 56, 0)", +"hsla(150 12.5% 25% / 0.0)", "rgba(56, 72, 64, 0)", +"hsla(180 12.5% 25% / 0.0)", "rgba(56, 72, 72, 0)", +"hsla(210 12.5% 25% / 0.0)", "rgba(56, 64, 72, 0)", +"hsla(240 12.5% 25% / 0.0)", "rgba(56, 56, 72, 0)", +"hsla(270 12.5% 25% / 0.0)", "rgba(64, 56, 72, 0)", +"hsla(300 12.5% 25% / 0.0)", "rgba(72, 56, 72, 0)", +"hsla(330 12.5% 25% / 0.0)", "rgba(72, 56, 64, 0)", +"hsla(0 25% 25% / 0.0)", "rgba(80, 48, 48, 0)", +"hsla(30 25% 25% / 0.0)", "rgba(80, 64, 48, 0)", +"hsla(60 25% 25% / 0.0)", "rgba(80, 80, 48, 0)", +"hsla(90 25% 25% / 0.0)", "rgba(64, 80, 48, 0)", +"hsla(120 25% 25% / 0.0)", "rgba(48, 80, 48, 0)", +"hsla(150 25% 25% / 0.0)", "rgba(48, 80, 64, 0)", +"hsla(180 25% 25% / 0.0)", "rgba(48, 80, 80, 0)", +"hsla(210 25% 25% / 0.0)", "rgba(48, 64, 80, 0)", +"hsla(240 25% 25% / 0.0)", "rgba(48, 48, 80, 0)", +"hsla(270 25% 25% / 0.0)", "rgba(64, 48, 80, 0)", +"hsla(300 25% 25% / 0.0)", "rgba(80, 48, 80, 0)", +"hsla(330 25% 25% / 0.0)", "rgba(80, 48, 64, 0)", +"hsla(0 37.5% 25% / 0.0)", "rgba(88, 40, 40, 0)", +"hsla(30 37.5% 25% / 0.0)", "rgba(88, 64, 40, 0)", +"hsla(60 37.5% 25% / 0.0)", "rgba(88, 88, 40, 0)", +"hsla(90 37.5% 25% / 0.0)", "rgba(64, 88, 40, 0)", +"hsla(120 37.5% 25% / 0.0)", "rgba(40, 88, 40, 0)", +"hsla(150 37.5% 25% / 0.0)", "rgba(40, 88, 64, 0)", +"hsla(180 37.5% 25% / 0.0)", "rgba(40, 88, 88, 0)", +"hsla(210 37.5% 25% / 0.0)", "rgba(40, 64, 88, 0)", +"hsla(240 37.5% 25% / 0.0)", "rgba(40, 40, 88, 0)", +"hsla(270 37.5% 25% / 0.0)", "rgba(64, 40, 88, 0)", +"hsla(300 37.5% 25% / 0.0)", "rgba(88, 40, 88, 0)", +"hsla(330 37.5% 25% / 0.0)", "rgba(88, 40, 64, 0)", +"hsla(0 50% 25% / 0.0)", "rgba(96, 32, 32, 0)", +"hsla(30 50% 25% / 0.0)", "rgba(96, 64, 32, 0)", +"hsla(60 50% 25% / 0.0)", "rgba(96, 96, 32, 0)", +"hsla(90 50% 25% / 0.0)", "rgba(64, 96, 32, 0)", +"hsla(120 50% 25% / 0.0)", "rgba(32, 96, 32, 0)", +"hsla(150 50% 25% / 0.0)", "rgba(32, 96, 64, 0)", +"hsla(180 50% 25% / 0.0)", "rgba(32, 96, 96, 0)", +"hsla(210 50% 25% / 0.0)", "rgba(32, 64, 96, 0)", +"hsla(240 50% 25% / 0.0)", "rgba(32, 32, 96, 0)", +"hsla(270 50% 25% / 0.0)", "rgba(64, 32, 96, 0)", +"hsla(300 50% 25% / 0.0)", "rgba(96, 32, 96, 0)", +"hsla(330 50% 25% / 0.0)", "rgba(96, 32, 64, 0)", +"hsla(0 62.5% 25% / 0.0)", "rgba(104, 24, 24, 0)", +"hsla(30 62.5% 25% / 0.0)", "rgba(104, 64, 24, 0)", +"hsla(60 62.5% 25% / 0.0)", "rgba(104, 104, 24, 0)", +"hsla(90 62.5% 25% / 0.0)", "rgba(64, 104, 24, 0)", +"hsla(120 62.5% 25% / 0.0)", "rgba(24, 104, 24, 0)", +"hsla(150 62.5% 25% / 0.0)", "rgba(24, 104, 64, 0)", +"hsla(180 62.5% 25% / 0.0)", "rgba(24, 104, 104, 0)", +"hsla(210 62.5% 25% / 0.0)", "rgba(24, 64, 104, 0)", +"hsla(240 62.5% 25% / 0.0)", "rgba(24, 24, 104, 0)", +"hsla(270 62.5% 25% / 0.0)", "rgba(64, 24, 104, 0)", +"hsla(300 62.5% 25% / 0.0)", "rgba(104, 24, 104, 0)", +"hsla(330 62.5% 25% / 0.0)", "rgba(104, 24, 64, 0)", +"hsla(0 75% 25% / 0.0)", "rgba(112, 16, 16, 0)", +"hsla(30 75% 25% / 0.0)", "rgba(112, 64, 16, 0)", +"hsla(60 75% 25% / 0.0)", "rgba(112, 112, 16, 0)", +"hsla(90 75% 25% / 0.0)", "rgba(64, 112, 16, 0)", +"hsla(120 75% 25% / 0.0)", "rgba(16, 112, 16, 0)", +"hsla(150 75% 25% / 0.0)", "rgba(16, 112, 64, 0)", +"hsla(180 75% 25% / 0.0)", "rgba(16, 112, 112, 0)", +"hsla(210 75% 25% / 0.0)", "rgba(16, 64, 112, 0)", +"hsla(240 75% 25% / 0.0)", "rgba(16, 16, 112, 0)", +"hsla(270 75% 25% / 0.0)", "rgba(64, 16, 112, 0)", +"hsla(300 75% 25% / 0.0)", "rgba(112, 16, 112, 0)", +"hsla(330 75% 25% / 0.0)", "rgba(112, 16, 64, 0)", +"hsla(0 87.5% 25% / 0.0)", "rgba(120, 8, 8, 0)", +"hsla(30 87.5% 25% / 0.0)", "rgba(120, 64, 8, 0)", +"hsla(60 87.5% 25% / 0.0)", "rgba(120, 120, 8, 0)", +"hsla(90 87.5% 25% / 0.0)", "rgba(64, 120, 8, 0)", +"hsla(120 87.5% 25% / 0.0)", "rgba(8, 120, 8, 0)", +"hsla(150 87.5% 25% / 0.0)", "rgba(8, 120, 64, 0)", +"hsla(180 87.5% 25% / 0.0)", "rgba(8, 120, 120, 0)", +"hsla(210 87.5% 25% / 0.0)", "rgba(8, 64, 120, 0)", +"hsla(240 87.5% 25% / 0.0)", "rgba(8, 8, 120, 0)", +"hsla(270 87.5% 25% / 0.0)", "rgba(64, 8, 120, 0)", +"hsla(300 87.5% 25% / 0.0)", "rgba(120, 8, 120, 0)", +"hsla(330 87.5% 25% / 0.0)", "rgba(120, 8, 64, 0)", +"hsla(0 100% 25% / 0.0)", "rgba(128, 0, 0, 0)", +"hsla(30 100% 25% / 0.0)", "rgba(128, 64, 0, 0)", +"hsla(60 100% 25% / 0.0)", "rgba(128, 128, 0, 0)", +"hsla(90 100% 25% / 0.0)", "rgba(64, 128, 0, 0)", +"hsla(120 100% 25% / 0.0)", "rgba(0, 128, 0, 0)", +"hsla(150 100% 25% / 0.0)", "rgba(0, 128, 64, 0)", +"hsla(180 100% 25% / 0.0)", "rgba(0, 128, 128, 0)", +"hsla(210 100% 25% / 0.0)", "rgba(0, 64, 128, 0)", +"hsla(240 100% 25% / 0.0)", "rgba(0, 0, 128, 0)", +"hsla(270 100% 25% / 0.0)", "rgba(64, 0, 128, 0)", +"hsla(300 100% 25% / 0.0)", "rgba(128, 0, 128, 0)", +"hsla(330 100% 25% / 0.0)", "rgba(128, 0, 64, 0)", +"hsla(0 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(30 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(60 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(90 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(120 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(150 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(180 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(210 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(240 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(270 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(300 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(330 0% 37.5% / 0.0)", "rgba(96, 96, 96, 0)", +"hsla(0 12.5% 37.5% / 0.0)", "rgba(108, 84, 84, 0)", +"hsla(30 12.5% 37.5% / 0.0)", "rgba(108, 96, 84, 0)", +"hsla(60 12.5% 37.5% / 0.0)", "rgba(108, 108, 84, 0)", +"hsla(90 12.5% 37.5% / 0.0)", "rgba(96, 108, 84, 0)", +"hsla(120 12.5% 37.5% / 0.0)", "rgba(84, 108, 84, 0)", +"hsla(150 12.5% 37.5% / 0.0)", "rgba(84, 108, 96, 0)", +"hsla(180 12.5% 37.5% / 0.0)", "rgba(84, 108, 108, 0)", +"hsla(210 12.5% 37.5% / 0.0)", "rgba(84, 96, 108, 0)", +"hsla(240 12.5% 37.5% / 0.0)", "rgba(84, 84, 108, 0)", +"hsla(270 12.5% 37.5% / 0.0)", "rgba(96, 84, 108, 0)", +"hsla(300 12.5% 37.5% / 0.0)", "rgba(108, 84, 108, 0)", +"hsla(330 12.5% 37.5% / 0.0)", "rgba(108, 84, 96, 0)", +"hsla(0 25% 37.5% / 0.0)", "rgba(120, 72, 72, 0)", +"hsla(30 25% 37.5% / 0.0)", "rgba(120, 96, 72, 0)", +"hsla(60 25% 37.5% / 0.0)", "rgba(120, 120, 72, 0)", +"hsla(90 25% 37.5% / 0.0)", "rgba(96, 120, 72, 0)", +"hsla(120 25% 37.5% / 0.0)", "rgba(72, 120, 72, 0)", +"hsla(150 25% 37.5% / 0.0)", "rgba(72, 120, 96, 0)", +"hsla(180 25% 37.5% / 0.0)", "rgba(72, 120, 120, 0)", +"hsla(210 25% 37.5% / 0.0)", "rgba(72, 96, 120, 0)", +"hsla(240 25% 37.5% / 0.0)", "rgba(72, 72, 120, 0)", +"hsla(270 25% 37.5% / 0.0)", "rgba(96, 72, 120, 0)", +"hsla(300 25% 37.5% / 0.0)", "rgba(120, 72, 120, 0)", +"hsla(330 25% 37.5% / 0.0)", "rgba(120, 72, 96, 0)", +"hsla(0 37.5% 37.5% / 0.0)", "rgba(131, 60, 60, 0)", +"hsla(30 37.5% 37.5% / 0.0)", "rgba(131, 96, 60, 0)", +"hsla(60 37.5% 37.5% / 0.0)", "rgba(131, 131, 60, 0)", +"hsla(90 37.5% 37.5% / 0.0)", "rgba(96, 131, 60, 0)", +"hsla(120 37.5% 37.5% / 0.0)", "rgba(60, 131, 60, 0)", +"hsla(150 37.5% 37.5% / 0.0)", "rgba(60, 131, 96, 0)", +"hsla(180 37.5% 37.5% / 0.0)", "rgba(60, 131, 131, 0)", +"hsla(210 37.5% 37.5% / 0.0)", "rgba(60, 96, 131, 0)", +"hsla(240 37.5% 37.5% / 0.0)", "rgba(60, 60, 131, 0)", +"hsla(270 37.5% 37.5% / 0.0)", "rgba(96, 60, 131, 0)", +"hsla(300 37.5% 37.5% / 0.0)", "rgba(131, 60, 131, 0)", +"hsla(330 37.5% 37.5% / 0.0)", "rgba(131, 60, 96, 0)", +"hsla(0 50% 37.5% / 0.0)", "rgba(143, 48, 48, 0)", +"hsla(30 50% 37.5% / 0.0)", "rgba(143, 96, 48, 0)", +"hsla(60 50% 37.5% / 0.0)", "rgba(143, 143, 48, 0)", +"hsla(90 50% 37.5% / 0.0)", "rgba(96, 143, 48, 0)", +"hsla(120 50% 37.5% / 0.0)", "rgba(48, 143, 48, 0)", +"hsla(150 50% 37.5% / 0.0)", "rgba(48, 143, 96, 0)", +"hsla(180 50% 37.5% / 0.0)", "rgba(48, 143, 143, 0)", +"hsla(210 50% 37.5% / 0.0)", "rgba(48, 96, 143, 0)", +"hsla(240 50% 37.5% / 0.0)", "rgba(48, 48, 143, 0)", +"hsla(270 50% 37.5% / 0.0)", "rgba(96, 48, 143, 0)", +"hsla(300 50% 37.5% / 0.0)", "rgba(143, 48, 143, 0)", +"hsla(330 50% 37.5% / 0.0)", "rgba(143, 48, 96, 0)", +"hsla(0 62.5% 37.5% / 0.0)", "rgba(155, 36, 36, 0)", +"hsla(30 62.5% 37.5% / 0.0)", "rgba(155, 96, 36, 0)", +"hsla(60 62.5% 37.5% / 0.0)", "rgba(155, 155, 36, 0)", +"hsla(90 62.5% 37.5% / 0.0)", "rgba(96, 155, 36, 0)", +"hsla(120 62.5% 37.5% / 0.0)", "rgba(36, 155, 36, 0)", +"hsla(150 62.5% 37.5% / 0.0)", "rgba(36, 155, 96, 0)", +"hsla(180 62.5% 37.5% / 0.0)", "rgba(36, 155, 155, 0)", +"hsla(210 62.5% 37.5% / 0.0)", "rgba(36, 96, 155, 0)", +"hsla(240 62.5% 37.5% / 0.0)", "rgba(36, 36, 155, 0)", +"hsla(270 62.5% 37.5% / 0.0)", "rgba(96, 36, 155, 0)", +"hsla(300 62.5% 37.5% / 0.0)", "rgba(155, 36, 155, 0)", +"hsla(330 62.5% 37.5% / 0.0)", "rgba(155, 36, 96, 0)", +"hsla(0 75% 37.5% / 0.0)", "rgba(167, 24, 24, 0)", +"hsla(30 75% 37.5% / 0.0)", "rgba(167, 96, 24, 0)", +"hsla(60 75% 37.5% / 0.0)", "rgba(167, 167, 24, 0)", +"hsla(90 75% 37.5% / 0.0)", "rgba(96, 167, 24, 0)", +"hsla(120 75% 37.5% / 0.0)", "rgba(24, 167, 24, 0)", +"hsla(150 75% 37.5% / 0.0)", "rgba(24, 167, 96, 0)", +"hsla(180 75% 37.5% / 0.0)", "rgba(24, 167, 167, 0)", +"hsla(210 75% 37.5% / 0.0)", "rgba(24, 96, 167, 0)", +"hsla(240 75% 37.5% / 0.0)", "rgba(24, 24, 167, 0)", +"hsla(270 75% 37.5% / 0.0)", "rgba(96, 24, 167, 0)", +"hsla(300 75% 37.5% / 0.0)", "rgba(167, 24, 167, 0)", +"hsla(330 75% 37.5% / 0.0)", "rgba(167, 24, 96, 0)", +"hsla(0 87.5% 37.5% / 0.0)", "rgba(179, 12, 12, 0)", +"hsla(30 87.5% 37.5% / 0.0)", "rgba(179, 96, 12, 0)", +"hsla(60 87.5% 37.5% / 0.0)", "rgba(179, 179, 12, 0)", +"hsla(90 87.5% 37.5% / 0.0)", "rgba(96, 179, 12, 0)", +"hsla(120 87.5% 37.5% / 0.0)", "rgba(12, 179, 12, 0)", +"hsla(150 87.5% 37.5% / 0.0)", "rgba(12, 179, 96, 0)", +"hsla(180 87.5% 37.5% / 0.0)", "rgba(12, 179, 179, 0)", +"hsla(210 87.5% 37.5% / 0.0)", "rgba(12, 96, 179, 0)", +"hsla(240 87.5% 37.5% / 0.0)", "rgba(12, 12, 179, 0)", +"hsla(270 87.5% 37.5% / 0.0)", "rgba(96, 12, 179, 0)", +"hsla(300 87.5% 37.5% / 0.0)", "rgba(179, 12, 179, 0)", +"hsla(330 87.5% 37.5% / 0.0)", "rgba(179, 12, 96, 0)", +"hsla(0 100% 37.5% / 0.0)", "rgba(191, 0, 0, 0)", +"hsla(30 100% 37.5% / 0.0)", "rgba(191, 96, 0, 0)", +"hsla(60 100% 37.5% / 0.0)", "rgba(191, 191, 0, 0)", +"hsla(90 100% 37.5% / 0.0)", "rgba(96, 191, 0, 0)", +"hsla(120 100% 37.5% / 0.0)", "rgba(0, 191, 0, 0)", +"hsla(150 100% 37.5% / 0.0)", "rgba(0, 191, 96, 0)", +"hsla(180 100% 37.5% / 0.0)", "rgba(0, 191, 191, 0)", +"hsla(210 100% 37.5% / 0.0)", "rgba(0, 96, 191, 0)", +"hsla(240 100% 37.5% / 0.0)", "rgba(0, 0, 191, 0)", +"hsla(270 100% 37.5% / 0.0)", "rgba(96, 0, 191, 0)", +"hsla(300 100% 37.5% / 0.0)", "rgba(191, 0, 191, 0)", +"hsla(330 100% 37.5% / 0.0)", "rgba(191, 0, 96, 0)", +"hsla(0 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(30 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(60 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(90 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(120 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(150 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(180 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(210 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(240 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(270 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(300 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(330 0% 50% / 0.0)", "rgba(128, 128, 128, 0)", +"hsla(0 12.5% 50% / 0.0)", "rgba(143, 112, 112, 0)", +"hsla(30 12.5% 50% / 0.0)", "rgba(143, 128, 112, 0)", +"hsla(60 12.5% 50% / 0.0)", "rgba(143, 143, 112, 0)", +"hsla(90 12.5% 50% / 0.0)", "rgba(128, 143, 112, 0)", +"hsla(120 12.5% 50% / 0.0)", "rgba(112, 143, 112, 0)", +"hsla(150 12.5% 50% / 0.0)", "rgba(112, 143, 128, 0)", +"hsla(180 12.5% 50% / 0.0)", "rgba(112, 143, 143, 0)", +"hsla(210 12.5% 50% / 0.0)", "rgba(112, 128, 143, 0)", +"hsla(240 12.5% 50% / 0.0)", "rgba(112, 112, 143, 0)", +"hsla(270 12.5% 50% / 0.0)", "rgba(128, 112, 143, 0)", +"hsla(300 12.5% 50% / 0.0)", "rgba(143, 112, 143, 0)", +"hsla(330 12.5% 50% / 0.0)", "rgba(143, 112, 128, 0)", +"hsla(0 25% 50% / 0.0)", "rgba(159, 96, 96, 0)", +"hsla(30 25% 50% / 0.0)", "rgba(159, 128, 96, 0)", +"hsla(60 25% 50% / 0.0)", "rgba(159, 159, 96, 0)", +"hsla(90 25% 50% / 0.0)", "rgba(128, 159, 96, 0)", +"hsla(120 25% 50% / 0.0)", "rgba(96, 159, 96, 0)", +"hsla(150 25% 50% / 0.0)", "rgba(96, 159, 128, 0)", +"hsla(180 25% 50% / 0.0)", "rgba(96, 159, 159, 0)", +"hsla(210 25% 50% / 0.0)", "rgba(96, 128, 159, 0)", +"hsla(240 25% 50% / 0.0)", "rgba(96, 96, 159, 0)", +"hsla(270 25% 50% / 0.0)", "rgba(128, 96, 159, 0)", +"hsla(300 25% 50% / 0.0)", "rgba(159, 96, 159, 0)", +"hsla(330 25% 50% / 0.0)", "rgba(159, 96, 128, 0)", +"hsla(0 37.5% 50% / 0.0)", "rgba(175, 80, 80, 0)", +"hsla(30 37.5% 50% / 0.0)", "rgba(175, 128, 80, 0)", +"hsla(60 37.5% 50% / 0.0)", "rgba(175, 175, 80, 0)", +"hsla(90 37.5% 50% / 0.0)", "rgba(128, 175, 80, 0)", +"hsla(120 37.5% 50% / 0.0)", "rgba(80, 175, 80, 0)", +"hsla(150 37.5% 50% / 0.0)", "rgba(80, 175, 128, 0)", +"hsla(180 37.5% 50% / 0.0)", "rgba(80, 175, 175, 0)", +"hsla(210 37.5% 50% / 0.0)", "rgba(80, 128, 175, 0)", +"hsla(240 37.5% 50% / 0.0)", "rgba(80, 80, 175, 0)", +"hsla(270 37.5% 50% / 0.0)", "rgba(128, 80, 175, 0)", +"hsla(300 37.5% 50% / 0.0)", "rgba(175, 80, 175, 0)", +"hsla(330 37.5% 50% / 0.0)", "rgba(175, 80, 128, 0)", +"hsla(0 50% 50% / 0.0)", "rgba(191, 64, 64, 0)", +"hsla(30 50% 50% / 0.0)", "rgba(191, 128, 64, 0)", +"hsla(60 50% 50% / 0.0)", "rgba(191, 191, 64, 0)", +"hsla(90 50% 50% / 0.0)", "rgba(128, 191, 64, 0)", +"hsla(120 50% 50% / 0.0)", "rgba(64, 191, 64, 0)", +"hsla(150 50% 50% / 0.0)", "rgba(64, 191, 128, 0)", +"hsla(180 50% 50% / 0.0)", "rgba(64, 191, 191, 0)", +"hsla(210 50% 50% / 0.0)", "rgba(64, 128, 191, 0)", +"hsla(240 50% 50% / 0.0)", "rgba(64, 64, 191, 0)", +"hsla(270 50% 50% / 0.0)", "rgba(128, 64, 191, 0)", +"hsla(300 50% 50% / 0.0)", "rgba(191, 64, 191, 0)", +"hsla(330 50% 50% / 0.0)", "rgba(191, 64, 128, 0)", +"hsla(0 62.5% 50% / 0.0)", "rgba(207, 48, 48, 0)", +"hsla(30 62.5% 50% / 0.0)", "rgba(207, 128, 48, 0)", +"hsla(60 62.5% 50% / 0.0)", "rgba(207, 207, 48, 0)", +"hsla(90 62.5% 50% / 0.0)", "rgba(128, 207, 48, 0)", +"hsla(120 62.5% 50% / 0.0)", "rgba(48, 207, 48, 0)", +"hsla(150 62.5% 50% / 0.0)", "rgba(48, 207, 128, 0)", +"hsla(180 62.5% 50% / 0.0)", "rgba(48, 207, 207, 0)", +"hsla(210 62.5% 50% / 0.0)", "rgba(48, 128, 207, 0)", +"hsla(240 62.5% 50% / 0.0)", "rgba(48, 48, 207, 0)", +"hsla(270 62.5% 50% / 0.0)", "rgba(128, 48, 207, 0)", +"hsla(300 62.5% 50% / 0.0)", "rgba(207, 48, 207, 0)", +"hsla(330 62.5% 50% / 0.0)", "rgba(207, 48, 128, 0)", +"hsla(0 75% 50% / 0.0)", "rgba(223, 32, 32, 0)", +"hsla(30 75% 50% / 0.0)", "rgba(223, 128, 32, 0)", +"hsla(60 75% 50% / 0.0)", "rgba(223, 223, 32, 0)", +"hsla(90 75% 50% / 0.0)", "rgba(128, 223, 32, 0)", +"hsla(120 75% 50% / 0.0)", "rgba(32, 223, 32, 0)", +"hsla(150 75% 50% / 0.0)", "rgba(32, 223, 128, 0)", +"hsla(180 75% 50% / 0.0)", "rgba(32, 223, 223, 0)", +"hsla(210 75% 50% / 0.0)", "rgba(32, 128, 223, 0)", +"hsla(240 75% 50% / 0.0)", "rgba(32, 32, 223, 0)", +"hsla(270 75% 50% / 0.0)", "rgba(128, 32, 223, 0)", +"hsla(300 75% 50% / 0.0)", "rgba(223, 32, 223, 0)", +"hsla(330 75% 50% / 0.0)", "rgba(223, 32, 128, 0)", +"hsla(0 87.5% 50% / 0.0)", "rgba(239, 16, 16, 0)", +"hsla(30 87.5% 50% / 0.0)", "rgba(239, 128, 16, 0)", +"hsla(60 87.5% 50% / 0.0)", "rgba(239, 239, 16, 0)", +"hsla(90 87.5% 50% / 0.0)", "rgba(128, 239, 16, 0)", +"hsla(120 87.5% 50% / 0.0)", "rgba(16, 239, 16, 0)", +"hsla(150 87.5% 50% / 0.0)", "rgba(16, 239, 128, 0)", +"hsla(180 87.5% 50% / 0.0)", "rgba(16, 239, 239, 0)", +"hsla(210 87.5% 50% / 0.0)", "rgba(16, 128, 239, 0)", +"hsla(240 87.5% 50% / 0.0)", "rgba(16, 16, 239, 0)", +"hsla(270 87.5% 50% / 0.0)", "rgba(128, 16, 239, 0)", +"hsla(300 87.5% 50% / 0.0)", "rgba(239, 16, 239, 0)", +"hsla(330 87.5% 50% / 0.0)", "rgba(239, 16, 128, 0)", +"hsla(0 100% 50% / 0.0)", "rgba(255, 0, 0, 0)", +"hsla(30 100% 50% / 0.0)", "rgba(255, 128, 0, 0)", +"hsla(60 100% 50% / 0.0)", "rgba(255, 255, 0, 0)", +"hsla(90 100% 50% / 0.0)", "rgba(128, 255, 0, 0)", +"hsla(120 100% 50% / 0.0)", "rgba(0, 255, 0, 0)", +"hsla(150 100% 50% / 0.0)", "rgba(0, 255, 128, 0)", +"hsla(180 100% 50% / 0.0)", "rgba(0, 255, 255, 0)", +"hsla(210 100% 50% / 0.0)", "rgba(0, 128, 255, 0)", +"hsla(240 100% 50% / 0.0)", "rgba(0, 0, 255, 0)", +"hsla(270 100% 50% / 0.0)", "rgba(128, 0, 255, 0)", +"hsla(300 100% 50% / 0.0)", "rgba(255, 0, 255, 0)", +"hsla(330 100% 50% / 0.0)", "rgba(255, 0, 128, 0)", +"hsla(0 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(30 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(60 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(90 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(120 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(150 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(180 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(210 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(240 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(270 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(300 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(330 0% 62.5% / 0.0)", "rgba(159, 159, 159, 0)", +"hsla(0 12.5% 62.5% / 0.0)", "rgba(171, 147, 147, 0)", +"hsla(30 12.5% 62.5% / 0.0)", "rgba(171, 159, 147, 0)", +"hsla(60 12.5% 62.5% / 0.0)", "rgba(171, 171, 147, 0)", +"hsla(90 12.5% 62.5% / 0.0)", "rgba(159, 171, 147, 0)", +"hsla(120 12.5% 62.5% / 0.0)", "rgba(147, 171, 147, 0)", +"hsla(150 12.5% 62.5% / 0.0)", "rgba(147, 171, 159, 0)", +"hsla(180 12.5% 62.5% / 0.0)", "rgba(147, 171, 171, 0)", +"hsla(210 12.5% 62.5% / 0.0)", "rgba(147, 159, 171, 0)", +"hsla(240 12.5% 62.5% / 0.0)", "rgba(147, 147, 171, 0)", +"hsla(270 12.5% 62.5% / 0.0)", "rgba(159, 147, 171, 0)", +"hsla(300 12.5% 62.5% / 0.0)", "rgba(171, 147, 171, 0)", +"hsla(330 12.5% 62.5% / 0.0)", "rgba(171, 147, 159, 0)", +"hsla(0 25% 62.5% / 0.0)", "rgba(183, 135, 135, 0)", +"hsla(30 25% 62.5% / 0.0)", "rgba(183, 159, 135, 0)", +"hsla(60 25% 62.5% / 0.0)", "rgba(183, 183, 135, 0)", +"hsla(90 25% 62.5% / 0.0)", "rgba(159, 183, 135, 0)", +"hsla(120 25% 62.5% / 0.0)", "rgba(135, 183, 135, 0)", +"hsla(150 25% 62.5% / 0.0)", "rgba(135, 183, 159, 0)", +"hsla(180 25% 62.5% / 0.0)", "rgba(135, 183, 183, 0)", +"hsla(210 25% 62.5% / 0.0)", "rgba(135, 159, 183, 0)", +"hsla(240 25% 62.5% / 0.0)", "rgba(135, 135, 183, 0)", +"hsla(270 25% 62.5% / 0.0)", "rgba(159, 135, 183, 0)", +"hsla(300 25% 62.5% / 0.0)", "rgba(183, 135, 183, 0)", +"hsla(330 25% 62.5% / 0.0)", "rgba(183, 135, 159, 0)", +"hsla(0 37.5% 62.5% / 0.0)", "rgba(195, 124, 124, 0)", +"hsla(30 37.5% 62.5% / 0.0)", "rgba(195, 159, 124, 0)", +"hsla(60 37.5% 62.5% / 0.0)", "rgba(195, 195, 124, 0)", +"hsla(90 37.5% 62.5% / 0.0)", "rgba(159, 195, 124, 0)", +"hsla(120 37.5% 62.5% / 0.0)", "rgba(124, 195, 124, 0)", +"hsla(150 37.5% 62.5% / 0.0)", "rgba(124, 195, 159, 0)", +"hsla(180 37.5% 62.5% / 0.0)", "rgba(124, 195, 195, 0)", +"hsla(210 37.5% 62.5% / 0.0)", "rgba(124, 159, 195, 0)", +"hsla(240 37.5% 62.5% / 0.0)", "rgba(124, 124, 195, 0)", +"hsla(270 37.5% 62.5% / 0.0)", "rgba(159, 124, 195, 0)", +"hsla(300 37.5% 62.5% / 0.0)", "rgba(195, 124, 195, 0)", +"hsla(330 37.5% 62.5% / 0.0)", "rgba(195, 124, 159, 0)", +"hsla(0 50% 62.5% / 0.0)", "rgba(207, 112, 112, 0)", +"hsla(30 50% 62.5% / 0.0)", "rgba(207, 159, 112, 0)", +"hsla(60 50% 62.5% / 0.0)", "rgba(207, 207, 112, 0)", +"hsla(90 50% 62.5% / 0.0)", "rgba(159, 207, 112, 0)", +"hsla(120 50% 62.5% / 0.0)", "rgba(112, 207, 112, 0)", +"hsla(150 50% 62.5% / 0.0)", "rgba(112, 207, 159, 0)", +"hsla(180 50% 62.5% / 0.0)", "rgba(112, 207, 207, 0)", +"hsla(210 50% 62.5% / 0.0)", "rgba(112, 159, 207, 0)", +"hsla(240 50% 62.5% / 0.0)", "rgba(112, 112, 207, 0)", +"hsla(270 50% 62.5% / 0.0)", "rgba(159, 112, 207, 0)", +"hsla(300 50% 62.5% / 0.0)", "rgba(207, 112, 207, 0)", +"hsla(330 50% 62.5% / 0.0)", "rgba(207, 112, 159, 0)", +"hsla(0 62.5% 62.5% / 0.0)", "rgba(219, 100, 100, 0)", +"hsla(30 62.5% 62.5% / 0.0)", "rgba(219, 159, 100, 0)", +"hsla(60 62.5% 62.5% / 0.0)", "rgba(219, 219, 100, 0)", +"hsla(90 62.5% 62.5% / 0.0)", "rgba(159, 219, 100, 0)", +"hsla(120 62.5% 62.5% / 0.0)", "rgba(100, 219, 100, 0)", +"hsla(150 62.5% 62.5% / 0.0)", "rgba(100, 219, 159, 0)", +"hsla(180 62.5% 62.5% / 0.0)", "rgba(100, 219, 219, 0)", +"hsla(210 62.5% 62.5% / 0.0)", "rgba(100, 159, 219, 0)", +"hsla(240 62.5% 62.5% / 0.0)", "rgba(100, 100, 219, 0)", +"hsla(270 62.5% 62.5% / 0.0)", "rgba(159, 100, 219, 0)", +"hsla(300 62.5% 62.5% / 0.0)", "rgba(219, 100, 219, 0)", +"hsla(330 62.5% 62.5% / 0.0)", "rgba(219, 100, 159, 0)", +"hsla(0 75% 62.5% / 0.0)", "rgba(231, 88, 88, 0)", +"hsla(30 75% 62.5% / 0.0)", "rgba(231, 159, 88, 0)", +"hsla(60 75% 62.5% / 0.0)", "rgba(231, 231, 88, 0)", +"hsla(90 75% 62.5% / 0.0)", "rgba(159, 231, 88, 0)", +"hsla(120 75% 62.5% / 0.0)", "rgba(88, 231, 88, 0)", +"hsla(150 75% 62.5% / 0.0)", "rgba(88, 231, 159, 0)", +"hsla(180 75% 62.5% / 0.0)", "rgba(88, 231, 231, 0)", +"hsla(210 75% 62.5% / 0.0)", "rgba(88, 159, 231, 0)", +"hsla(240 75% 62.5% / 0.0)", "rgba(88, 88, 231, 0)", +"hsla(270 75% 62.5% / 0.0)", "rgba(159, 88, 231, 0)", +"hsla(300 75% 62.5% / 0.0)", "rgba(231, 88, 231, 0)", +"hsla(330 75% 62.5% / 0.0)", "rgba(231, 88, 159, 0)", +"hsla(0 87.5% 62.5% / 0.0)", "rgba(243, 76, 76, 0)", +"hsla(30 87.5% 62.5% / 0.0)", "rgba(243, 159, 76, 0)", +"hsla(60 87.5% 62.5% / 0.0)", "rgba(243, 243, 76, 0)", +"hsla(90 87.5% 62.5% / 0.0)", "rgba(159, 243, 76, 0)", +"hsla(120 87.5% 62.5% / 0.0)", "rgba(76, 243, 76, 0)", +"hsla(150 87.5% 62.5% / 0.0)", "rgba(76, 243, 159, 0)", +"hsla(180 87.5% 62.5% / 0.0)", "rgba(76, 243, 243, 0)", +"hsla(210 87.5% 62.5% / 0.0)", "rgba(76, 159, 243, 0)", +"hsla(240 87.5% 62.5% / 0.0)", "rgba(76, 76, 243, 0)", +"hsla(270 87.5% 62.5% / 0.0)", "rgba(159, 76, 243, 0)", +"hsla(300 87.5% 62.5% / 0.0)", "rgba(243, 76, 243, 0)", +"hsla(330 87.5% 62.5% / 0.0)", "rgba(243, 76, 159, 0)", +"hsla(0 100% 62.5% / 0.0)", "rgba(255, 64, 64, 0)", +"hsla(30 100% 62.5% / 0.0)", "rgba(255, 159, 64, 0)", +"hsla(60 100% 62.5% / 0.0)", "rgba(255, 255, 64, 0)", +"hsla(90 100% 62.5% / 0.0)", "rgba(159, 255, 64, 0)", +"hsla(120 100% 62.5% / 0.0)", "rgba(64, 255, 64, 0)", +"hsla(150 100% 62.5% / 0.0)", "rgba(64, 255, 159, 0)", +"hsla(180 100% 62.5% / 0.0)", "rgba(64, 255, 255, 0)", +"hsla(210 100% 62.5% / 0.0)", "rgba(64, 159, 255, 0)", +"hsla(240 100% 62.5% / 0.0)", "rgba(64, 64, 255, 0)", +"hsla(270 100% 62.5% / 0.0)", "rgba(159, 64, 255, 0)", +"hsla(300 100% 62.5% / 0.0)", "rgba(255, 64, 255, 0)", +"hsla(330 100% 62.5% / 0.0)", "rgba(255, 64, 159, 0)", +"hsla(0 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(30 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(60 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(90 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(120 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(150 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(180 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(210 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(240 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(270 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(300 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(330 0% 75% / 0.0)", "rgba(191, 191, 191, 0)", +"hsla(0 12.5% 75% / 0.0)", "rgba(199, 183, 183, 0)", +"hsla(30 12.5% 75% / 0.0)", "rgba(199, 191, 183, 0)", +"hsla(60 12.5% 75% / 0.0)", "rgba(199, 199, 183, 0)", +"hsla(90 12.5% 75% / 0.0)", "rgba(191, 199, 183, 0)", +"hsla(120 12.5% 75% / 0.0)", "rgba(183, 199, 183, 0)", +"hsla(150 12.5% 75% / 0.0)", "rgba(183, 199, 191, 0)", +"hsla(180 12.5% 75% / 0.0)", "rgba(183, 199, 199, 0)", +"hsla(210 12.5% 75% / 0.0)", "rgba(183, 191, 199, 0)", +"hsla(240 12.5% 75% / 0.0)", "rgba(183, 183, 199, 0)", +"hsla(270 12.5% 75% / 0.0)", "rgba(191, 183, 199, 0)", +"hsla(300 12.5% 75% / 0.0)", "rgba(199, 183, 199, 0)", +"hsla(330 12.5% 75% / 0.0)", "rgba(199, 183, 191, 0)", +"hsla(0 25% 75% / 0.0)", "rgba(207, 175, 175, 0)", +"hsla(30 25% 75% / 0.0)", "rgba(207, 191, 175, 0)", +"hsla(60 25% 75% / 0.0)", "rgba(207, 207, 175, 0)", +"hsla(90 25% 75% / 0.0)", "rgba(191, 207, 175, 0)", +"hsla(120 25% 75% / 0.0)", "rgba(175, 207, 175, 0)", +"hsla(150 25% 75% / 0.0)", "rgba(175, 207, 191, 0)", +"hsla(180 25% 75% / 0.0)", "rgba(175, 207, 207, 0)", +"hsla(210 25% 75% / 0.0)", "rgba(175, 191, 207, 0)", +"hsla(240 25% 75% / 0.0)", "rgba(175, 175, 207, 0)", +"hsla(270 25% 75% / 0.0)", "rgba(191, 175, 207, 0)", +"hsla(300 25% 75% / 0.0)", "rgba(207, 175, 207, 0)", +"hsla(330 25% 75% / 0.0)", "rgba(207, 175, 191, 0)", +"hsla(0 37.5% 75% / 0.0)", "rgba(215, 167, 167, 0)", +"hsla(30 37.5% 75% / 0.0)", "rgba(215, 191, 167, 0)", +"hsla(60 37.5% 75% / 0.0)", "rgba(215, 215, 167, 0)", +"hsla(90 37.5% 75% / 0.0)", "rgba(191, 215, 167, 0)", +"hsla(120 37.5% 75% / 0.0)", "rgba(167, 215, 167, 0)", +"hsla(150 37.5% 75% / 0.0)", "rgba(167, 215, 191, 0)", +"hsla(180 37.5% 75% / 0.0)", "rgba(167, 215, 215, 0)", +"hsla(210 37.5% 75% / 0.0)", "rgba(167, 191, 215, 0)", +"hsla(240 37.5% 75% / 0.0)", "rgba(167, 167, 215, 0)", +"hsla(270 37.5% 75% / 0.0)", "rgba(191, 167, 215, 0)", +"hsla(300 37.5% 75% / 0.0)", "rgba(215, 167, 215, 0)", +"hsla(330 37.5% 75% / 0.0)", "rgba(215, 167, 191, 0)", +"hsla(0 50% 75% / 0.0)", "rgba(223, 159, 159, 0)", +"hsla(30 50% 75% / 0.0)", "rgba(223, 191, 159, 0)", +"hsla(60 50% 75% / 0.0)", "rgba(223, 223, 159, 0)", +"hsla(90 50% 75% / 0.0)", "rgba(191, 223, 159, 0)", +"hsla(120 50% 75% / 0.0)", "rgba(159, 223, 159, 0)", +"hsla(150 50% 75% / 0.0)", "rgba(159, 223, 191, 0)", +"hsla(180 50% 75% / 0.0)", "rgba(159, 223, 223, 0)", +"hsla(210 50% 75% / 0.0)", "rgba(159, 191, 223, 0)", +"hsla(240 50% 75% / 0.0)", "rgba(159, 159, 223, 0)", +"hsla(270 50% 75% / 0.0)", "rgba(191, 159, 223, 0)", +"hsla(300 50% 75% / 0.0)", "rgba(223, 159, 223, 0)", +"hsla(330 50% 75% / 0.0)", "rgba(223, 159, 191, 0)", +"hsla(0 62.5% 75% / 0.0)", "rgba(231, 151, 151, 0)", +"hsla(30 62.5% 75% / 0.0)", "rgba(231, 191, 151, 0)", +"hsla(60 62.5% 75% / 0.0)", "rgba(231, 231, 151, 0)", +"hsla(90 62.5% 75% / 0.0)", "rgba(191, 231, 151, 0)", +"hsla(120 62.5% 75% / 0.0)", "rgba(151, 231, 151, 0)", +"hsla(150 62.5% 75% / 0.0)", "rgba(151, 231, 191, 0)", +"hsla(180 62.5% 75% / 0.0)", "rgba(151, 231, 231, 0)", +"hsla(210 62.5% 75% / 0.0)", "rgba(151, 191, 231, 0)", +"hsla(240 62.5% 75% / 0.0)", "rgba(151, 151, 231, 0)", +"hsla(270 62.5% 75% / 0.0)", "rgba(191, 151, 231, 0)", +"hsla(300 62.5% 75% / 0.0)", "rgba(231, 151, 231, 0)", +"hsla(330 62.5% 75% / 0.0)", "rgba(231, 151, 191, 0)", +"hsla(0 75% 75% / 0.0)", "rgba(239, 143, 143, 0)", +"hsla(30 75% 75% / 0.0)", "rgba(239, 191, 143, 0)", +"hsla(60 75% 75% / 0.0)", "rgba(239, 239, 143, 0)", +"hsla(90 75% 75% / 0.0)", "rgba(191, 239, 143, 0)", +"hsla(120 75% 75% / 0.0)", "rgba(143, 239, 143, 0)", +"hsla(150 75% 75% / 0.0)", "rgba(143, 239, 191, 0)", +"hsla(180 75% 75% / 0.0)", "rgba(143, 239, 239, 0)", +"hsla(210 75% 75% / 0.0)", "rgba(143, 191, 239, 0)", +"hsla(240 75% 75% / 0.0)", "rgba(143, 143, 239, 0)", +"hsla(270 75% 75% / 0.0)", "rgba(191, 143, 239, 0)", +"hsla(300 75% 75% / 0.0)", "rgba(239, 143, 239, 0)", +"hsla(330 75% 75% / 0.0)", "rgba(239, 143, 191, 0)", +"hsla(0 87.5% 75% / 0.0)", "rgba(247, 135, 135, 0)", +"hsla(30 87.5% 75% / 0.0)", "rgba(247, 191, 135, 0)", +"hsla(60 87.5% 75% / 0.0)", "rgba(247, 247, 135, 0)", +"hsla(90 87.5% 75% / 0.0)", "rgba(191, 247, 135, 0)", +"hsla(120 87.5% 75% / 0.0)", "rgba(135, 247, 135, 0)", +"hsla(150 87.5% 75% / 0.0)", "rgba(135, 247, 191, 0)", +"hsla(180 87.5% 75% / 0.0)", "rgba(135, 247, 247, 0)", +"hsla(210 87.5% 75% / 0.0)", "rgba(135, 191, 247, 0)", +"hsla(240 87.5% 75% / 0.0)", "rgba(135, 135, 247, 0)", +"hsla(270 87.5% 75% / 0.0)", "rgba(191, 135, 247, 0)", +"hsla(300 87.5% 75% / 0.0)", "rgba(247, 135, 247, 0)", +"hsla(330 87.5% 75% / 0.0)", "rgba(247, 135, 191, 0)", +"hsla(0 100% 75% / 0.0)", "rgba(255, 128, 128, 0)", +"hsla(30 100% 75% / 0.0)", "rgba(255, 191, 128, 0)", +"hsla(60 100% 75% / 0.0)", "rgba(255, 255, 128, 0)", +"hsla(90 100% 75% / 0.0)", "rgba(191, 255, 128, 0)", +"hsla(120 100% 75% / 0.0)", "rgba(128, 255, 128, 0)", +"hsla(150 100% 75% / 0.0)", "rgba(128, 255, 191, 0)", +"hsla(180 100% 75% / 0.0)", "rgba(128, 255, 255, 0)", +"hsla(210 100% 75% / 0.0)", "rgba(128, 191, 255, 0)", +"hsla(240 100% 75% / 0.0)", "rgba(128, 128, 255, 0)", +"hsla(270 100% 75% / 0.0)", "rgba(191, 128, 255, 0)", +"hsla(300 100% 75% / 0.0)", "rgba(255, 128, 255, 0)", +"hsla(330 100% 75% / 0.0)", "rgba(255, 128, 191, 0)", +"hsla(0 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(30 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(60 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(90 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(120 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(150 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(180 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(210 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(240 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(270 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(300 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(330 0% 87.5% / 0.0)", "rgba(223, 223, 223, 0)", +"hsla(0 12.5% 87.5% / 0.0)", "rgba(227, 219, 219, 0)", +"hsla(30 12.5% 87.5% / 0.0)", "rgba(227, 223, 219, 0)", +"hsla(60 12.5% 87.5% / 0.0)", "rgba(227, 227, 219, 0)", +"hsla(90 12.5% 87.5% / 0.0)", "rgba(223, 227, 219, 0)", +"hsla(120 12.5% 87.5% / 0.0)", "rgba(219, 227, 219, 0)", +"hsla(150 12.5% 87.5% / 0.0)", "rgba(219, 227, 223, 0)", +"hsla(180 12.5% 87.5% / 0.0)", "rgba(219, 227, 227, 0)", +"hsla(210 12.5% 87.5% / 0.0)", "rgba(219, 223, 227, 0)", +"hsla(240 12.5% 87.5% / 0.0)", "rgba(219, 219, 227, 0)", +"hsla(270 12.5% 87.5% / 0.0)", "rgba(223, 219, 227, 0)", +"hsla(300 12.5% 87.5% / 0.0)", "rgba(227, 219, 227, 0)", +"hsla(330 12.5% 87.5% / 0.0)", "rgba(227, 219, 223, 0)", +"hsla(0 25% 87.5% / 0.0)", "rgba(231, 215, 215, 0)", +"hsla(30 25% 87.5% / 0.0)", "rgba(231, 223, 215, 0)", +"hsla(60 25% 87.5% / 0.0)", "rgba(231, 231, 215, 0)", +"hsla(90 25% 87.5% / 0.0)", "rgba(223, 231, 215, 0)", +"hsla(120 25% 87.5% / 0.0)", "rgba(215, 231, 215, 0)", +"hsla(150 25% 87.5% / 0.0)", "rgba(215, 231, 223, 0)", +"hsla(180 25% 87.5% / 0.0)", "rgba(215, 231, 231, 0)", +"hsla(210 25% 87.5% / 0.0)", "rgba(215, 223, 231, 0)", +"hsla(240 25% 87.5% / 0.0)", "rgba(215, 215, 231, 0)", +"hsla(270 25% 87.5% / 0.0)", "rgba(223, 215, 231, 0)", +"hsla(300 25% 87.5% / 0.0)", "rgba(231, 215, 231, 0)", +"hsla(330 25% 87.5% / 0.0)", "rgba(231, 215, 223, 0)", +"hsla(0 37.5% 87.5% / 0.0)", "rgba(235, 211, 211, 0)", +"hsla(30 37.5% 87.5% / 0.0)", "rgba(235, 223, 211, 0)", +"hsla(60 37.5% 87.5% / 0.0)", "rgba(235, 235, 211, 0)", +"hsla(90 37.5% 87.5% / 0.0)", "rgba(223, 235, 211, 0)", +"hsla(120 37.5% 87.5% / 0.0)", "rgba(211, 235, 211, 0)", +"hsla(150 37.5% 87.5% / 0.0)", "rgba(211, 235, 223, 0)", +"hsla(180 37.5% 87.5% / 0.0)", "rgba(211, 235, 235, 0)", +"hsla(210 37.5% 87.5% / 0.0)", "rgba(211, 223, 235, 0)", +"hsla(240 37.5% 87.5% / 0.0)", "rgba(211, 211, 235, 0)", +"hsla(270 37.5% 87.5% / 0.0)", "rgba(223, 211, 235, 0)", +"hsla(300 37.5% 87.5% / 0.0)", "rgba(235, 211, 235, 0)", +"hsla(330 37.5% 87.5% / 0.0)", "rgba(235, 211, 223, 0)", +"hsla(0 50% 87.5% / 0.0)", "rgba(239, 207, 207, 0)", +"hsla(30 50% 87.5% / 0.0)", "rgba(239, 223, 207, 0)", +"hsla(60 50% 87.5% / 0.0)", "rgba(239, 239, 207, 0)", +"hsla(90 50% 87.5% / 0.0)", "rgba(223, 239, 207, 0)", +"hsla(120 50% 87.5% / 0.0)", "rgba(207, 239, 207, 0)", +"hsla(150 50% 87.5% / 0.0)", "rgba(207, 239, 223, 0)", +"hsla(180 50% 87.5% / 0.0)", "rgba(207, 239, 239, 0)", +"hsla(210 50% 87.5% / 0.0)", "rgba(207, 223, 239, 0)", +"hsla(240 50% 87.5% / 0.0)", "rgba(207, 207, 239, 0)", +"hsla(270 50% 87.5% / 0.0)", "rgba(223, 207, 239, 0)", +"hsla(300 50% 87.5% / 0.0)", "rgba(239, 207, 239, 0)", +"hsla(330 50% 87.5% / 0.0)", "rgba(239, 207, 223, 0)", +"hsla(0 62.5% 87.5% / 0.0)", "rgba(243, 203, 203, 0)", +"hsla(30 62.5% 87.5% / 0.0)", "rgba(243, 223, 203, 0)", +"hsla(60 62.5% 87.5% / 0.0)", "rgba(243, 243, 203, 0)", +"hsla(90 62.5% 87.5% / 0.0)", "rgba(223, 243, 203, 0)", +"hsla(120 62.5% 87.5% / 0.0)", "rgba(203, 243, 203, 0)", +"hsla(150 62.5% 87.5% / 0.0)", "rgba(203, 243, 223, 0)", +"hsla(180 62.5% 87.5% / 0.0)", "rgba(203, 243, 243, 0)", +"hsla(210 62.5% 87.5% / 0.0)", "rgba(203, 223, 243, 0)", +"hsla(240 62.5% 87.5% / 0.0)", "rgba(203, 203, 243, 0)", +"hsla(270 62.5% 87.5% / 0.0)", "rgba(223, 203, 243, 0)", +"hsla(300 62.5% 87.5% / 0.0)", "rgba(243, 203, 243, 0)", +"hsla(330 62.5% 87.5% / 0.0)", "rgba(243, 203, 223, 0)", +"hsla(0 75% 87.5% / 0.0)", "rgba(247, 199, 199, 0)", +"hsla(30 75% 87.5% / 0.0)", "rgba(247, 223, 199, 0)", +"hsla(60 75% 87.5% / 0.0)", "rgba(247, 247, 199, 0)", +"hsla(90 75% 87.5% / 0.0)", "rgba(223, 247, 199, 0)", +"hsla(120 75% 87.5% / 0.0)", "rgba(199, 247, 199, 0)", +"hsla(150 75% 87.5% / 0.0)", "rgba(199, 247, 223, 0)", +"hsla(180 75% 87.5% / 0.0)", "rgba(199, 247, 247, 0)", +"hsla(210 75% 87.5% / 0.0)", "rgba(199, 223, 247, 0)", +"hsla(240 75% 87.5% / 0.0)", "rgba(199, 199, 247, 0)", +"hsla(270 75% 87.5% / 0.0)", "rgba(223, 199, 247, 0)", +"hsla(300 75% 87.5% / 0.0)", "rgba(247, 199, 247, 0)", +"hsla(330 75% 87.5% / 0.0)", "rgba(247, 199, 223, 0)", +"hsla(0 87.5% 87.5% / 0.0)", "rgba(251, 195, 195, 0)", +"hsla(30 87.5% 87.5% / 0.0)", "rgba(251, 223, 195, 0)", +"hsla(60 87.5% 87.5% / 0.0)", "rgba(251, 251, 195, 0)", +"hsla(90 87.5% 87.5% / 0.0)", "rgba(223, 251, 195, 0)", +"hsla(120 87.5% 87.5% / 0.0)", "rgba(195, 251, 195, 0)", +"hsla(150 87.5% 87.5% / 0.0)", "rgba(195, 251, 223, 0)", +"hsla(180 87.5% 87.5% / 0.0)", "rgba(195, 251, 251, 0)", +"hsla(210 87.5% 87.5% / 0.0)", "rgba(195, 223, 251, 0)", +"hsla(240 87.5% 87.5% / 0.0)", "rgba(195, 195, 251, 0)", +"hsla(270 87.5% 87.5% / 0.0)", "rgba(223, 195, 251, 0)", +"hsla(300 87.5% 87.5% / 0.0)", "rgba(251, 195, 251, 0)", +"hsla(330 87.5% 87.5% / 0.0)", "rgba(251, 195, 223, 0)", +"hsla(0 100% 87.5% / 0.0)", "rgba(255, 191, 191, 0)", +"hsla(30 100% 87.5% / 0.0)", "rgba(255, 223, 191, 0)", +"hsla(60 100% 87.5% / 0.0)", "rgba(255, 255, 191, 0)", +"hsla(90 100% 87.5% / 0.0)", "rgba(223, 255, 191, 0)", +"hsla(120 100% 87.5% / 0.0)", "rgba(191, 255, 191, 0)", +"hsla(150 100% 87.5% / 0.0)", "rgba(191, 255, 223, 0)", +"hsla(180 100% 87.5% / 0.0)", "rgba(191, 255, 255, 0)", +"hsla(210 100% 87.5% / 0.0)", "rgba(191, 223, 255, 0)", +"hsla(240 100% 87.5% / 0.0)", "rgba(191, 191, 255, 0)", +"hsla(270 100% 87.5% / 0.0)", "rgba(223, 191, 255, 0)", +"hsla(300 100% 87.5% / 0.0)", "rgba(255, 191, 255, 0)", +"hsla(330 100% 87.5% / 0.0)", "rgba(255, 191, 223, 0)", +"hsla(0 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 0% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 12.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 25% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 37.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 50% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 62.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 75% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 87.5% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(0 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(30 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(60 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(90 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(120 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(150 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(180 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(210 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(240 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(270 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(300 100% 100% / 0.0)", "rgba(255, 255, 255, 0)", +"hsla(330 100% 100% / 0.0)", "rgba(255, 255, 255, 0)" +]
diff --git a/src/css-parsing-tests/color3_keywords.json b/src/css-parsing-tests/color3_keywords.json new file mode 100644 index 0000000..7db6825 --- /dev/null +++ b/src/css-parsing-tests/color3_keywords.json
@@ -0,0 +1,803 @@ +[ +"transparent", "rgba(0, 0, 0, 0)", +"Transparent", "rgba(0, 0, 0, 0)", +"\\transparent", "rgba(0, 0, 0, 0)", +"\\74 ransparent", "rgba(0, 0, 0, 0)", +"ransparent", null, +"black", "rgb(0, 0, 0)", +"bLack", "rgb(0, 0, 0)", +"b\\lack", "rgb(0, 0, 0)", +"b\\6C ack", "rgb(0, 0, 0)", +"back", null, +"blacK", null, +"silver", "rgb(192, 192, 192)", +"siLver", "rgb(192, 192, 192)", +"si\\lver", "rgb(192, 192, 192)", +"si\\6C ver", "rgb(192, 192, 192)", +"siver", null, +"gray", "rgb(128, 128, 128)", +"graY", "rgb(128, 128, 128)", +"gra\\y", "rgb(128, 128, 128)", +"gra\\79 ", "rgb(128, 128, 128)", +"gra", null, +"white", "rgb(255, 255, 255)", +"whitE", "rgb(255, 255, 255)", +"whit\\65 ", "rgb(255, 255, 255)", +"whit", null, +"maroon", "rgb(128, 0, 0)", +"marooN", "rgb(128, 0, 0)", +"maroo\\n", "rgb(128, 0, 0)", +"maroo\\6E ", "rgb(128, 0, 0)", +"maroo", null, +"red", "rgb(255, 0, 0)", +"Red", "rgb(255, 0, 0)", +"\\red", "rgb(255, 0, 0)", +"\\72 ed", "rgb(255, 0, 0)", +"ed", null, +"purple", "rgb(128, 0, 128)", +"pUrple", "rgb(128, 0, 128)", +"p\\urple", "rgb(128, 0, 128)", +"p\\75 rple", "rgb(128, 0, 128)", +"prple", null, +"fuchsia", "rgb(255, 0, 255)", +"fUchsia", "rgb(255, 0, 255)", +"f\\uchsia", "rgb(255, 0, 255)", +"f\\75 chsia", "rgb(255, 0, 255)", +"fchsia", null, +"green", "rgb(0, 128, 0)", +"greeN", "rgb(0, 128, 0)", +"gree\\n", "rgb(0, 128, 0)", +"gree\\6E ", "rgb(0, 128, 0)", +"gree", null, +"lime", "rgb(0, 255, 0)", +"liMe", "rgb(0, 255, 0)", +"li\\me", "rgb(0, 255, 0)", +"li\\6D e", "rgb(0, 255, 0)", +"lie", null, +"olive", "rgb(128, 128, 0)", +"oLive", "rgb(128, 128, 0)", +"o\\live", "rgb(128, 128, 0)", +"o\\6C ive", "rgb(128, 128, 0)", +"oive", null, +"yellow", "rgb(255, 255, 0)", +"Yellow", "rgb(255, 255, 0)", +"\\yellow", "rgb(255, 255, 0)", +"\\79 ellow", "rgb(255, 255, 0)", +"ellow", null, +"navy", "rgb(0, 0, 128)", +"nAvy", "rgb(0, 0, 128)", +"n\\61 vy", "rgb(0, 0, 128)", +"nvy", null, +"blue", "rgb(0, 0, 255)", +"blUe", "rgb(0, 0, 255)", +"bl\\ue", "rgb(0, 0, 255)", +"bl\\75 e", "rgb(0, 0, 255)", +"ble", null, +"teal", "rgb(0, 128, 128)", +"teaL", "rgb(0, 128, 128)", +"tea\\l", "rgb(0, 128, 128)", +"tea\\6C ", "rgb(0, 128, 128)", +"tea", null, +"aqua", "rgb(0, 255, 255)", +"Aqua", "rgb(0, 255, 255)", +"\\61 qua", "rgb(0, 255, 255)", +"qua", null, +"aliceblue", "rgb(240, 248, 255)", +"alicebluE", "rgb(240, 248, 255)", +"aliceblu\\65 ", "rgb(240, 248, 255)", +"aliceblu", null, +"antiquewhite", "rgb(250, 235, 215)", +"antiquEwhite", "rgb(250, 235, 215)", +"antiqu\\65 white", "rgb(250, 235, 215)", +"antiquwhite", null, +"aqua", "rgb(0, 255, 255)", +"aquA", "rgb(0, 255, 255)", +"aqu\\61 ", "rgb(0, 255, 255)", +"aqu", null, +"aquamarine", "rgb(127, 255, 212)", +"Aquamarine", "rgb(127, 255, 212)", +"\\61 quamarine", "rgb(127, 255, 212)", +"quamarine", null, +"azure", "rgb(240, 255, 255)", +"aZure", "rgb(240, 255, 255)", +"a\\zure", "rgb(240, 255, 255)", +"a\\7A ure", "rgb(240, 255, 255)", +"aure", null, +"beige", "rgb(245, 245, 220)", +"beIge", "rgb(245, 245, 220)", +"be\\ige", "rgb(245, 245, 220)", +"be\\69 ge", "rgb(245, 245, 220)", +"bege", null, +"bisque", "rgb(255, 228, 196)", +"bisquE", "rgb(255, 228, 196)", +"bisqu\\65 ", "rgb(255, 228, 196)", +"bisqu", null, +"black", "rgb(0, 0, 0)", +"blacK", "rgb(0, 0, 0)", +"blac\\k", "rgb(0, 0, 0)", +"blac\\6B ", "rgb(0, 0, 0)", +"blac", null, +"blacK", null, +"blanchedalmond", "rgb(255, 235, 205)", +"blanchedalmOnd", "rgb(255, 235, 205)", +"blanchedalm\\ond", "rgb(255, 235, 205)", +"blanchedalm\\6F nd", "rgb(255, 235, 205)", +"blanchedalmnd", null, +"blue", "rgb(0, 0, 255)", +"blUe", "rgb(0, 0, 255)", +"bl\\ue", "rgb(0, 0, 255)", +"bl\\75 e", "rgb(0, 0, 255)", +"ble", null, +"blueviolet", "rgb(138, 43, 226)", +"bluevioLet", "rgb(138, 43, 226)", +"bluevio\\let", "rgb(138, 43, 226)", +"bluevio\\6C et", "rgb(138, 43, 226)", +"bluevioet", null, +"brown", "rgb(165, 42, 42)", +"broWn", "rgb(165, 42, 42)", +"bro\\wn", "rgb(165, 42, 42)", +"bro\\77 n", "rgb(165, 42, 42)", +"bron", null, +"burlywood", "rgb(222, 184, 135)", +"buRlywood", "rgb(222, 184, 135)", +"bu\\rlywood", "rgb(222, 184, 135)", +"bu\\72 lywood", "rgb(222, 184, 135)", +"bulywood", null, +"cadetblue", "rgb(95, 158, 160)", +"cadEtblue", "rgb(95, 158, 160)", +"cad\\65 tblue", "rgb(95, 158, 160)", +"cadtblue", null, +"chartreuse", "rgb(127, 255, 0)", +"cHartreuse", "rgb(127, 255, 0)", +"c\\hartreuse", "rgb(127, 255, 0)", +"c\\68 artreuse", "rgb(127, 255, 0)", +"cartreuse", null, +"chocolate", "rgb(210, 105, 30)", +"chocoLate", "rgb(210, 105, 30)", +"choco\\late", "rgb(210, 105, 30)", +"choco\\6C ate", "rgb(210, 105, 30)", +"chocoate", null, +"coral", "rgb(255, 127, 80)", +"corAl", "rgb(255, 127, 80)", +"cor\\61 l", "rgb(255, 127, 80)", +"corl", null, +"cornflowerblue", "rgb(100, 149, 237)", +"cornflOwerblue", "rgb(100, 149, 237)", +"cornfl\\owerblue", "rgb(100, 149, 237)", +"cornfl\\6F werblue", "rgb(100, 149, 237)", +"cornflwerblue", null, +"cornsilk", "rgb(255, 248, 220)", +"corNsilk", "rgb(255, 248, 220)", +"cor\\nsilk", "rgb(255, 248, 220)", +"cor\\6E silk", "rgb(255, 248, 220)", +"corsilk", null, +"cornsilK", null, +"crimson", "rgb(220, 20, 60)", +"cRimson", "rgb(220, 20, 60)", +"c\\rimson", "rgb(220, 20, 60)", +"c\\72 imson", "rgb(220, 20, 60)", +"cimson", null, +"cyan", "rgb(0, 255, 255)", +"cYan", "rgb(0, 255, 255)", +"c\\yan", "rgb(0, 255, 255)", +"c\\79 an", "rgb(0, 255, 255)", +"can", null, +"darkblue", "rgb(0, 0, 139)", +"darkblUe", "rgb(0, 0, 139)", +"darkbl\\ue", "rgb(0, 0, 139)", +"darkbl\\75 e", "rgb(0, 0, 139)", +"darkble", null, +"darKblue", null, +"darkcyan", "rgb(0, 139, 139)", +"darkcyaN", "rgb(0, 139, 139)", +"darkcya\\n", "rgb(0, 139, 139)", +"darkcya\\6E ", "rgb(0, 139, 139)", +"darkcya", null, +"darKcyan", null, +"darkgoldenrod", "rgb(184, 134, 11)", +"dArkgoldenrod", "rgb(184, 134, 11)", +"d\\61 rkgoldenrod", "rgb(184, 134, 11)", +"drkgoldenrod", null, +"darKgoldenrod", null, +"darkgray", "rgb(169, 169, 169)", +"dArkgray", "rgb(169, 169, 169)", +"d\\61 rkgray", "rgb(169, 169, 169)", +"drkgray", null, +"darKgray", null, +"darkgreen", "rgb(0, 100, 0)", +"darkgrEen", "rgb(0, 100, 0)", +"darkgr\\65 en", "rgb(0, 100, 0)", +"darkgren", null, +"darKgreen", null, +"darkgrey", "rgb(169, 169, 169)", +"darKgrey", "rgb(169, 169, 169)", +"dar\\kgrey", "rgb(169, 169, 169)", +"dar\\6B grey", "rgb(169, 169, 169)", +"dargrey", null, +"darKgrey", null, +"darkkhaki", "rgb(189, 183, 107)", +"darkkhakI", "rgb(189, 183, 107)", +"darkkhak\\i", "rgb(189, 183, 107)", +"darkkhak\\69 ", "rgb(189, 183, 107)", +"darkkhak", null, +"darKKhaKi", null, +"darkmagenta", "rgb(139, 0, 139)", +"dArkmagenta", "rgb(139, 0, 139)", +"d\\61 rkmagenta", "rgb(139, 0, 139)", +"drkmagenta", null, +"darKmagenta", null, +"darkolivegreen", "rgb(85, 107, 47)", +"darkOlivegreen", "rgb(85, 107, 47)", +"dark\\olivegreen", "rgb(85, 107, 47)", +"dark\\6F livegreen", "rgb(85, 107, 47)", +"darklivegreen", null, +"darKolivegreen", null, +"darkorange", "rgb(255, 140, 0)", +"darkoraNge", "rgb(255, 140, 0)", +"darkora\\nge", "rgb(255, 140, 0)", +"darkora\\6E ge", "rgb(255, 140, 0)", +"darkorage", null, +"darKorange", null, +"darkorchid", "rgb(153, 50, 204)", +"darkorchId", "rgb(153, 50, 204)", +"darkorch\\id", "rgb(153, 50, 204)", +"darkorch\\69 d", "rgb(153, 50, 204)", +"darkorchd", null, +"darKorchid", null, +"darkred", "rgb(139, 0, 0)", +"Darkred", "rgb(139, 0, 0)", +"\\64 arkred", "rgb(139, 0, 0)", +"arkred", null, +"darKred", null, +"darksalmon", "rgb(233, 150, 122)", +"Darksalmon", "rgb(233, 150, 122)", +"\\64 arksalmon", "rgb(233, 150, 122)", +"arksalmon", null, +"darKsalmon", null, +"darkseagreen", "rgb(143, 188, 143)", +"darKseagreen", "rgb(143, 188, 143)", +"dar\\kseagreen", "rgb(143, 188, 143)", +"dar\\6B seagreen", "rgb(143, 188, 143)", +"darseagreen", null, +"darKseagreen", null, +"darkslateblue", "rgb(72, 61, 139)", +"Darkslateblue", "rgb(72, 61, 139)", +"\\64 arkslateblue", "rgb(72, 61, 139)", +"arkslateblue", null, +"darKslateblue", null, +"darkslategray", "rgb(47, 79, 79)", +"dArkslategray", "rgb(47, 79, 79)", +"d\\61 rkslategray", "rgb(47, 79, 79)", +"drkslategray", null, +"darKslategray", null, +"darkslategrey", "rgb(47, 79, 79)", +"daRkslategrey", "rgb(47, 79, 79)", +"da\\rkslategrey", "rgb(47, 79, 79)", +"da\\72 kslategrey", "rgb(47, 79, 79)", +"dakslategrey", null, +"darKslategrey", null, +"darkturquoise", "rgb(0, 206, 209)", +"darKturquoise", "rgb(0, 206, 209)", +"dar\\kturquoise", "rgb(0, 206, 209)", +"dar\\6B turquoise", "rgb(0, 206, 209)", +"darturquoise", null, +"darKturquoise", null, +"darkviolet", "rgb(148, 0, 211)", +"darkviOlet", "rgb(148, 0, 211)", +"darkvi\\olet", "rgb(148, 0, 211)", +"darkvi\\6F let", "rgb(148, 0, 211)", +"darkvilet", null, +"darKviolet", null, +"deeppink", "rgb(255, 20, 147)", +"dEeppink", "rgb(255, 20, 147)", +"d\\65 eppink", "rgb(255, 20, 147)", +"deppink", null, +"deeppinK", null, +"deepskyblue", "rgb(0, 191, 255)", +"deePskyblue", "rgb(0, 191, 255)", +"dee\\pskyblue", "rgb(0, 191, 255)", +"dee\\70 skyblue", "rgb(0, 191, 255)", +"deeskyblue", null, +"deepsKyblue", null, +"dimgray", "rgb(105, 105, 105)", +"dimGray", "rgb(105, 105, 105)", +"dim\\gray", "rgb(105, 105, 105)", +"dim\\67 ray", "rgb(105, 105, 105)", +"dimray", null, +"dimgrey", "rgb(105, 105, 105)", +"dimgRey", "rgb(105, 105, 105)", +"dimg\\rey", "rgb(105, 105, 105)", +"dimg\\72 ey", "rgb(105, 105, 105)", +"dimgey", null, +"dodgerblue", "rgb(30, 144, 255)", +"dOdgerblue", "rgb(30, 144, 255)", +"d\\odgerblue", "rgb(30, 144, 255)", +"d\\6F dgerblue", "rgb(30, 144, 255)", +"ddgerblue", null, +"firebrick", "rgb(178, 34, 34)", +"firebricK", "rgb(178, 34, 34)", +"firebric\\k", "rgb(178, 34, 34)", +"firebric\\6B ", "rgb(178, 34, 34)", +"firebric", null, +"firebricK", null, +"floralwhite", "rgb(255, 250, 240)", +"floralwhIte", "rgb(255, 250, 240)", +"floralwh\\ite", "rgb(255, 250, 240)", +"floralwh\\69 te", "rgb(255, 250, 240)", +"floralwhte", null, +"forestgreen", "rgb(34, 139, 34)", +"forestgreEn", "rgb(34, 139, 34)", +"forestgre\\65 n", "rgb(34, 139, 34)", +"forestgren", null, +"fuchsia", "rgb(255, 0, 255)", +"fuChsia", "rgb(255, 0, 255)", +"fu\\63 hsia", "rgb(255, 0, 255)", +"fuhsia", null, +"gainsboro", "rgb(220, 220, 220)", +"gaiNsboro", "rgb(220, 220, 220)", +"gai\\nsboro", "rgb(220, 220, 220)", +"gai\\6E sboro", "rgb(220, 220, 220)", +"gaisboro", null, +"ghostwhite", "rgb(248, 248, 255)", +"ghostwhIte", "rgb(248, 248, 255)", +"ghostwh\\ite", "rgb(248, 248, 255)", +"ghostwh\\69 te", "rgb(248, 248, 255)", +"ghostwhte", null, +"gold", "rgb(255, 215, 0)", +"Gold", "rgb(255, 215, 0)", +"\\gold", "rgb(255, 215, 0)", +"\\67 old", "rgb(255, 215, 0)", +"old", null, +"goldenrod", "rgb(218, 165, 32)", +"goldenRod", "rgb(218, 165, 32)", +"golden\\rod", "rgb(218, 165, 32)", +"golden\\72 od", "rgb(218, 165, 32)", +"goldenod", null, +"gray", "rgb(128, 128, 128)", +"grAy", "rgb(128, 128, 128)", +"gr\\61 y", "rgb(128, 128, 128)", +"gry", null, +"green", "rgb(0, 128, 0)", +"gReen", "rgb(0, 128, 0)", +"g\\reen", "rgb(0, 128, 0)", +"g\\72 een", "rgb(0, 128, 0)", +"geen", null, +"greenyellow", "rgb(173, 255, 47)", +"greenyEllow", "rgb(173, 255, 47)", +"greeny\\65 llow", "rgb(173, 255, 47)", +"greenyllow", null, +"grey", "rgb(128, 128, 128)", +"gRey", "rgb(128, 128, 128)", +"g\\rey", "rgb(128, 128, 128)", +"g\\72 ey", "rgb(128, 128, 128)", +"gey", null, +"honeydew", "rgb(240, 255, 240)", +"hoNeydew", "rgb(240, 255, 240)", +"ho\\neydew", "rgb(240, 255, 240)", +"ho\\6E eydew", "rgb(240, 255, 240)", +"hoeydew", null, +"hotpink", "rgb(255, 105, 180)", +"hotpiNk", "rgb(255, 105, 180)", +"hotpi\\nk", "rgb(255, 105, 180)", +"hotpi\\6E k", "rgb(255, 105, 180)", +"hotpik", null, +"hotpinK", null, +"indianred", "rgb(205, 92, 92)", +"indiAnred", "rgb(205, 92, 92)", +"indi\\61 nred", "rgb(205, 92, 92)", +"indinred", null, +"indigo", "rgb(75, 0, 130)", +"indigO", "rgb(75, 0, 130)", +"indig\\o", "rgb(75, 0, 130)", +"indig\\6F ", "rgb(75, 0, 130)", +"indig", null, +"ivory", "rgb(255, 255, 240)", +"ivoRy", "rgb(255, 255, 240)", +"ivo\\ry", "rgb(255, 255, 240)", +"ivo\\72 y", "rgb(255, 255, 240)", +"ivoy", null, +"khaki", "rgb(240, 230, 140)", +"khakI", "rgb(240, 230, 140)", +"khak\\i", "rgb(240, 230, 140)", +"khak\\69 ", "rgb(240, 230, 140)", +"khak", null, +"KhaKi", null, +"lavender", "rgb(230, 230, 250)", +"Lavender", "rgb(230, 230, 250)", +"\\lavender", "rgb(230, 230, 250)", +"\\6C avender", "rgb(230, 230, 250)", +"avender", null, +"lavenderblush", "rgb(255, 240, 245)", +"lavEnderblush", "rgb(255, 240, 245)", +"lav\\65 nderblush", "rgb(255, 240, 245)", +"lavnderblush", null, +"lawngreen", "rgb(124, 252, 0)", +"lAwngreen", "rgb(124, 252, 0)", +"l\\61 wngreen", "rgb(124, 252, 0)", +"lwngreen", null, +"lemonchiffon", "rgb(255, 250, 205)", +"lemonchiffoN", "rgb(255, 250, 205)", +"lemonchiffo\\n", "rgb(255, 250, 205)", +"lemonchiffo\\6E ", "rgb(255, 250, 205)", +"lemonchiffo", null, +"lightblue", "rgb(173, 216, 230)", +"ligHtblue", "rgb(173, 216, 230)", +"lig\\htblue", "rgb(173, 216, 230)", +"lig\\68 tblue", "rgb(173, 216, 230)", +"ligtblue", null, +"lightcoral", "rgb(240, 128, 128)", +"lightCoral", "rgb(240, 128, 128)", +"light\\63 oral", "rgb(240, 128, 128)", +"lightoral", null, +"lightcyan", "rgb(224, 255, 255)", +"lightCyan", "rgb(224, 255, 255)", +"light\\63 yan", "rgb(224, 255, 255)", +"lightyan", null, +"lightgoldenrodyellow", "rgb(250, 250, 210)", +"lightgoLdenrodyellow", "rgb(250, 250, 210)", +"lightgo\\ldenrodyellow", "rgb(250, 250, 210)", +"lightgo\\6C denrodyellow", "rgb(250, 250, 210)", +"lightgodenrodyellow", null, +"lightgray", "rgb(211, 211, 211)", +"lightgrAy", "rgb(211, 211, 211)", +"lightgr\\61 y", "rgb(211, 211, 211)", +"lightgry", null, +"lightgreen", "rgb(144, 238, 144)", +"lightgreeN", "rgb(144, 238, 144)", +"lightgree\\n", "rgb(144, 238, 144)", +"lightgree\\6E ", "rgb(144, 238, 144)", +"lightgree", null, +"lightgrey", "rgb(211, 211, 211)", +"Lightgrey", "rgb(211, 211, 211)", +"\\lightgrey", "rgb(211, 211, 211)", +"\\6C ightgrey", "rgb(211, 211, 211)", +"ightgrey", null, +"lightpink", "rgb(255, 182, 193)", +"lIghtpink", "rgb(255, 182, 193)", +"l\\ightpink", "rgb(255, 182, 193)", +"l\\69 ghtpink", "rgb(255, 182, 193)", +"lghtpink", null, +"lightpinK", null, +"lightsalmon", "rgb(255, 160, 122)", +"lighTsalmon", "rgb(255, 160, 122)", +"ligh\\tsalmon", "rgb(255, 160, 122)", +"ligh\\74 salmon", "rgb(255, 160, 122)", +"lighsalmon", null, +"lightseagreen", "rgb(32, 178, 170)", +"liGhtseagreen", "rgb(32, 178, 170)", +"li\\ghtseagreen", "rgb(32, 178, 170)", +"li\\67 htseagreen", "rgb(32, 178, 170)", +"lihtseagreen", null, +"lightskyblue", "rgb(135, 206, 250)", +"lightskyblUe", "rgb(135, 206, 250)", +"lightskybl\\ue", "rgb(135, 206, 250)", +"lightskybl\\75 e", "rgb(135, 206, 250)", +"lightskyble", null, +"lightsKyblue", null, +"lightslategray", "rgb(119, 136, 153)", +"lightslategRay", "rgb(119, 136, 153)", +"lightslateg\\ray", "rgb(119, 136, 153)", +"lightslateg\\72 ay", "rgb(119, 136, 153)", +"lightslategay", null, +"lightslategrey", "rgb(119, 136, 153)", +"lightslategrEy", "rgb(119, 136, 153)", +"lightslategr\\65 y", "rgb(119, 136, 153)", +"lightslategry", null, +"lightsteelblue", "rgb(176, 196, 222)", +"lightsteelbluE", "rgb(176, 196, 222)", +"lightsteelblu\\65 ", "rgb(176, 196, 222)", +"lightsteelblu", null, +"lightyellow", "rgb(255, 255, 224)", +"lightyelloW", "rgb(255, 255, 224)", +"lightyello\\w", "rgb(255, 255, 224)", +"lightyello\\77 ", "rgb(255, 255, 224)", +"lightyello", null, +"lime", "rgb(0, 255, 0)", +"limE", "rgb(0, 255, 0)", +"lim\\65 ", "rgb(0, 255, 0)", +"lim", null, +"limegreen", "rgb(50, 205, 50)", +"lImegreen", "rgb(50, 205, 50)", +"l\\imegreen", "rgb(50, 205, 50)", +"l\\69 megreen", "rgb(50, 205, 50)", +"lmegreen", null, +"linen", "rgb(250, 240, 230)", +"lInen", "rgb(250, 240, 230)", +"l\\inen", "rgb(250, 240, 230)", +"l\\69 nen", "rgb(250, 240, 230)", +"lnen", null, +"magenta", "rgb(255, 0, 255)", +"mageNta", "rgb(255, 0, 255)", +"mage\\nta", "rgb(255, 0, 255)", +"mage\\6E ta", "rgb(255, 0, 255)", +"mageta", null, +"maroon", "rgb(128, 0, 0)", +"mAroon", "rgb(128, 0, 0)", +"m\\61 roon", "rgb(128, 0, 0)", +"mroon", null, +"mediumaquamarine", "rgb(102, 205, 170)", +"mediumaqUamarine", "rgb(102, 205, 170)", +"mediumaq\\uamarine", "rgb(102, 205, 170)", +"mediumaq\\75 amarine", "rgb(102, 205, 170)", +"mediumaqamarine", null, +"mediumblue", "rgb(0, 0, 205)", +"mediuMblue", "rgb(0, 0, 205)", +"mediu\\mblue", "rgb(0, 0, 205)", +"mediu\\6D blue", "rgb(0, 0, 205)", +"mediublue", null, +"mediumorchid", "rgb(186, 85, 211)", +"mediumorchId", "rgb(186, 85, 211)", +"mediumorch\\id", "rgb(186, 85, 211)", +"mediumorch\\69 d", "rgb(186, 85, 211)", +"mediumorchd", null, +"mediumpurple", "rgb(147, 112, 219)", +"mediumpurplE", "rgb(147, 112, 219)", +"mediumpurpl\\65 ", "rgb(147, 112, 219)", +"mediumpurpl", null, +"mediumseagreen", "rgb(60, 179, 113)", +"mediumseagReen", "rgb(60, 179, 113)", +"mediumseag\\reen", "rgb(60, 179, 113)", +"mediumseag\\72 een", "rgb(60, 179, 113)", +"mediumseageen", null, +"mediumslateblue", "rgb(123, 104, 238)", +"mediUmslateblue", "rgb(123, 104, 238)", +"medi\\umslateblue", "rgb(123, 104, 238)", +"medi\\75 mslateblue", "rgb(123, 104, 238)", +"medimslateblue", null, +"mediumspringgreen", "rgb(0, 250, 154)", +"mediumspRinggreen", "rgb(0, 250, 154)", +"mediumsp\\ringgreen", "rgb(0, 250, 154)", +"mediumsp\\72 inggreen", "rgb(0, 250, 154)", +"mediumspinggreen", null, +"mediumturquoise", "rgb(72, 209, 204)", +"mediumTurquoise", "rgb(72, 209, 204)", +"medium\\turquoise", "rgb(72, 209, 204)", +"medium\\74 urquoise", "rgb(72, 209, 204)", +"mediumurquoise", null, +"mediumvioletred", "rgb(199, 21, 133)", +"mediumvIoletred", "rgb(199, 21, 133)", +"mediumv\\ioletred", "rgb(199, 21, 133)", +"mediumv\\69 oletred", "rgb(199, 21, 133)", +"mediumvoletred", null, +"midnightblue", "rgb(25, 25, 112)", +"midniGhtblue", "rgb(25, 25, 112)", +"midni\\ghtblue", "rgb(25, 25, 112)", +"midni\\67 htblue", "rgb(25, 25, 112)", +"midnihtblue", null, +"mintcream", "rgb(245, 255, 250)", +"mintcrEam", "rgb(245, 255, 250)", +"mintcr\\65 am", "rgb(245, 255, 250)", +"mintcram", null, +"mistyrose", "rgb(255, 228, 225)", +"mistyroSe", "rgb(255, 228, 225)", +"mistyro\\se", "rgb(255, 228, 225)", +"mistyro\\73 e", "rgb(255, 228, 225)", +"mistyroe", null, +"moccasin", "rgb(255, 228, 181)", +"moccAsin", "rgb(255, 228, 181)", +"mocc\\61 sin", "rgb(255, 228, 181)", +"moccsin", null, +"navajowhite", "rgb(255, 222, 173)", +"navajowHite", "rgb(255, 222, 173)", +"navajow\\hite", "rgb(255, 222, 173)", +"navajow\\68 ite", "rgb(255, 222, 173)", +"navajowite", null, +"navy", "rgb(0, 0, 128)", +"naVy", "rgb(0, 0, 128)", +"na\\vy", "rgb(0, 0, 128)", +"na\\76 y", "rgb(0, 0, 128)", +"nay", null, +"oldlace", "rgb(253, 245, 230)", +"Oldlace", "rgb(253, 245, 230)", +"\\oldlace", "rgb(253, 245, 230)", +"\\6F ldlace", "rgb(253, 245, 230)", +"ldlace", null, +"olive", "rgb(128, 128, 0)", +"Olive", "rgb(128, 128, 0)", +"\\olive", "rgb(128, 128, 0)", +"\\6F live", "rgb(128, 128, 0)", +"live", null, +"olivedrab", "rgb(107, 142, 35)", +"olivEdrab", "rgb(107, 142, 35)", +"oliv\\65 drab", "rgb(107, 142, 35)", +"olivdrab", null, +"orange", "rgb(255, 165, 0)", +"orAnge", "rgb(255, 165, 0)", +"or\\61 nge", "rgb(255, 165, 0)", +"ornge", null, +"orangered", "rgb(255, 69, 0)", +"orangeRed", "rgb(255, 69, 0)", +"orange\\red", "rgb(255, 69, 0)", +"orange\\72 ed", "rgb(255, 69, 0)", +"orangeed", null, +"orchid", "rgb(218, 112, 214)", +"orchId", "rgb(218, 112, 214)", +"orch\\id", "rgb(218, 112, 214)", +"orch\\69 d", "rgb(218, 112, 214)", +"orchd", null, +"palegoldenrod", "rgb(238, 232, 170)", +"palegoldEnrod", "rgb(238, 232, 170)", +"palegold\\65 nrod", "rgb(238, 232, 170)", +"palegoldnrod", null, +"palegreen", "rgb(152, 251, 152)", +"Palegreen", "rgb(152, 251, 152)", +"\\palegreen", "rgb(152, 251, 152)", +"\\70 alegreen", "rgb(152, 251, 152)", +"alegreen", null, +"paleturquoise", "rgb(175, 238, 238)", +"paleturquoIse", "rgb(175, 238, 238)", +"paleturquo\\ise", "rgb(175, 238, 238)", +"paleturquo\\69 se", "rgb(175, 238, 238)", +"paleturquose", null, +"palevioletred", "rgb(219, 112, 147)", +"palevioletrEd", "rgb(219, 112, 147)", +"palevioletr\\65 d", "rgb(219, 112, 147)", +"palevioletrd", null, +"papayawhip", "rgb(255, 239, 213)", +"papayawhiP", "rgb(255, 239, 213)", +"papayawhi\\p", "rgb(255, 239, 213)", +"papayawhi\\70 ", "rgb(255, 239, 213)", +"papayawhi", null, +"peachpuff", "rgb(255, 218, 185)", +"peacHpuff", "rgb(255, 218, 185)", +"peac\\hpuff", "rgb(255, 218, 185)", +"peac\\68 puff", "rgb(255, 218, 185)", +"peacpuff", null, +"peru", "rgb(205, 133, 63)", +"perU", "rgb(205, 133, 63)", +"per\\u", "rgb(205, 133, 63)", +"per\\75 ", "rgb(205, 133, 63)", +"per", null, +"pink", "rgb(255, 192, 203)", +"Pink", "rgb(255, 192, 203)", +"\\pink", "rgb(255, 192, 203)", +"\\70 ink", "rgb(255, 192, 203)", +"ink", null, +"pinK", null, +"plum", "rgb(221, 160, 221)", +"pLum", "rgb(221, 160, 221)", +"p\\lum", "rgb(221, 160, 221)", +"p\\6C um", "rgb(221, 160, 221)", +"pum", null, +"powderblue", "rgb(176, 224, 230)", +"powdErblue", "rgb(176, 224, 230)", +"powd\\65 rblue", "rgb(176, 224, 230)", +"powdrblue", null, +"purple", "rgb(128, 0, 128)", +"purPle", "rgb(128, 0, 128)", +"pur\\ple", "rgb(128, 0, 128)", +"pur\\70 le", "rgb(128, 0, 128)", +"purle", null, +"red", "rgb(255, 0, 0)", +"rEd", "rgb(255, 0, 0)", +"r\\65 d", "rgb(255, 0, 0)", +"rd", null, +"rosybrown", "rgb(188, 143, 143)", +"roSybrown", "rgb(188, 143, 143)", +"ro\\sybrown", "rgb(188, 143, 143)", +"ro\\73 ybrown", "rgb(188, 143, 143)", +"roybrown", null, +"royalblue", "rgb(65, 105, 225)", +"royAlblue", "rgb(65, 105, 225)", +"roy\\61 lblue", "rgb(65, 105, 225)", +"roylblue", null, +"saddlebrown", "rgb(139, 69, 19)", +"saddlebRown", "rgb(139, 69, 19)", +"saddleb\\rown", "rgb(139, 69, 19)", +"saddleb\\72 own", "rgb(139, 69, 19)", +"saddlebown", null, +"salmon", "rgb(250, 128, 114)", +"saLmon", "rgb(250, 128, 114)", +"sa\\lmon", "rgb(250, 128, 114)", +"sa\\6C mon", "rgb(250, 128, 114)", +"samon", null, +"sandybrown", "rgb(244, 164, 96)", +"sAndybrown", "rgb(244, 164, 96)", +"s\\61 ndybrown", "rgb(244, 164, 96)", +"sndybrown", null, +"seagreen", "rgb(46, 139, 87)", +"seagreEn", "rgb(46, 139, 87)", +"seagre\\65 n", "rgb(46, 139, 87)", +"seagren", null, +"seashell", "rgb(255, 245, 238)", +"seashelL", "rgb(255, 245, 238)", +"seashel\\l", "rgb(255, 245, 238)", +"seashel\\6C ", "rgb(255, 245, 238)", +"seashel", null, +"sienna", "rgb(160, 82, 45)", +"Sienna", "rgb(160, 82, 45)", +"\\sienna", "rgb(160, 82, 45)", +"\\73 ienna", "rgb(160, 82, 45)", +"ienna", null, +"silver", "rgb(192, 192, 192)", +"sIlver", "rgb(192, 192, 192)", +"s\\ilver", "rgb(192, 192, 192)", +"s\\69 lver", "rgb(192, 192, 192)", +"slver", null, +"skyblue", "rgb(135, 206, 235)", +"skybluE", "rgb(135, 206, 235)", +"skyblu\\65 ", "rgb(135, 206, 235)", +"skyblu", null, +"sKyblue", null, +"slateblue", "rgb(106, 90, 205)", +"slaTeblue", "rgb(106, 90, 205)", +"sla\\teblue", "rgb(106, 90, 205)", +"sla\\74 eblue", "rgb(106, 90, 205)", +"slaeblue", null, +"slategray", "rgb(112, 128, 144)", +"slatEgray", "rgb(112, 128, 144)", +"slat\\65 gray", "rgb(112, 128, 144)", +"slatgray", null, +"slategrey", "rgb(112, 128, 144)", +"slateGrey", "rgb(112, 128, 144)", +"slate\\grey", "rgb(112, 128, 144)", +"slate\\67 rey", "rgb(112, 128, 144)", +"slaterey", null, +"snow", "rgb(255, 250, 250)", +"snOw", "rgb(255, 250, 250)", +"sn\\ow", "rgb(255, 250, 250)", +"sn\\6F w", "rgb(255, 250, 250)", +"snw", null, +"springgreen", "rgb(0, 255, 127)", +"springgrEen", "rgb(0, 255, 127)", +"springgr\\65 en", "rgb(0, 255, 127)", +"springgren", null, +"steelblue", "rgb(70, 130, 180)", +"steelbluE", "rgb(70, 130, 180)", +"steelblu\\65 ", "rgb(70, 130, 180)", +"steelblu", null, +"tan", "rgb(210, 180, 140)", +"Tan", "rgb(210, 180, 140)", +"\\tan", "rgb(210, 180, 140)", +"\\74 an", "rgb(210, 180, 140)", +"an", null, +"teal", "rgb(0, 128, 128)", +"teAl", "rgb(0, 128, 128)", +"te\\61 l", "rgb(0, 128, 128)", +"tel", null, +"thistle", "rgb(216, 191, 216)", +"tHistle", "rgb(216, 191, 216)", +"t\\histle", "rgb(216, 191, 216)", +"t\\68 istle", "rgb(216, 191, 216)", +"tistle", null, +"tomato", "rgb(255, 99, 71)", +"Tomato", "rgb(255, 99, 71)", +"\\tomato", "rgb(255, 99, 71)", +"\\74 omato", "rgb(255, 99, 71)", +"omato", null, +"turquoise", "rgb(64, 224, 208)", +"turqUoise", "rgb(64, 224, 208)", +"turq\\uoise", "rgb(64, 224, 208)", +"turq\\75 oise", "rgb(64, 224, 208)", +"turqoise", null, +"violet", "rgb(238, 130, 238)", +"viOlet", "rgb(238, 130, 238)", +"vi\\olet", "rgb(238, 130, 238)", +"vi\\6F let", "rgb(238, 130, 238)", +"vilet", null, +"wheat", "rgb(245, 222, 179)", +"wheaT", "rgb(245, 222, 179)", +"whea\\t", "rgb(245, 222, 179)", +"whea\\74 ", "rgb(245, 222, 179)", +"whea", null, +"white", "rgb(255, 255, 255)", +"White", "rgb(255, 255, 255)", +"\\white", "rgb(255, 255, 255)", +"\\77 hite", "rgb(255, 255, 255)", +"hite", null, +"whitesmoke", "rgb(245, 245, 245)", +"wHitesmoke", "rgb(245, 245, 245)", +"w\\hitesmoke", "rgb(245, 245, 245)", +"w\\68 itesmoke", "rgb(245, 245, 245)", +"witesmoke", null, +"whitesmoKe", null, +"yellow", "rgb(255, 255, 0)", +"Yellow", "rgb(255, 255, 0)", +"\\yellow", "rgb(255, 255, 0)", +"\\79 ellow", "rgb(255, 255, 0)", +"ellow", null, +"yellowgreen", "rgb(154, 205, 50)", +"yellowgreEn", "rgb(154, 205, 50)", +"yellowgre\\65 n", "rgb(154, 205, 50)", +"yellowgren", null +]
diff --git a/src/css-parsing-tests/color4_color_function.json b/src/css-parsing-tests/color4_color_function.json new file mode 100644 index 0000000..a653c65 --- /dev/null +++ b/src/css-parsing-tests/color4_color_function.json
@@ -0,0 +1,182 @@ +[ + "color(srgb 0% 0% 0%)", "color(srgb 0 0 0)", + "color(srgb 10% 10% 10%)", "color(srgb 0.1 0.1 0.1)", + "color(srgb .2 .2 25%)", "color(srgb 0.2 0.2 0.25)", + "color(srgb 0 0 0 / 1)", "color(srgb 0 0 0)", + "color(srgb 0% 0 0 / 0.5)", "color(srgb 0 0 0 / 0.5)", + "color(srgb 20% 0 10/0.5)", "color(srgb 0.2 0 10 / 0.5)", + "color(srgb 20% 0 10/50%)", "color(srgb 0.2 0 10 / 0.5)", + "color(srgb 400% 0 10/50%)", "color(srgb 4 0 10 / 0.5)", + "color(srgb 50% -160 160)", "color(srgb 0.5 -160 160)", + "color(srgb 50% -200 200)", "color(srgb 0.5 -200 200)", + "color(srgb 0 0 0 / -10%)", "color(srgb 0 0 0 / 0)", + "color(srgb 0 0 0 / 110%)", "color(srgb 0 0 0)", + "color(srgb 0 0 0 / 300%)", "color(srgb 0 0 0)", + "color(srgb 200 200 200)", "color(srgb 200 200 200)", + "color(srgb 200 200 200 / 200)", "color(srgb 200 200 200)", + "color(srgb -200 -200 -200)", "color(srgb -200 -200 -200)", + "color(srgb -200 -200 -200 / -200)", "color(srgb -200 -200 -200 / 0)", + "color(srgb 200% 200% 200%)", "color(srgb 2 2 2)", + "color(srgb 200% 200% 200% / 200%)", "color(srgb 2 2 2)", + "color(srgb -200% -200% -200% / -200%)", "color(srgb -2 -2 -2 / 0)", + "color(srgb-linear 0% 0% 0%)", "color(srgb-linear 0 0 0)", + "color(srgb-linear 10% 10% 10%)", "color(srgb-linear 0.1 0.1 0.1)", + "color(srgb-linear .2 .2 25%)", "color(srgb-linear 0.2 0.2 0.25)", + "color(srgb-linear 0 0 0 / 1)", "color(srgb-linear 0 0 0)", + "color(srgb-linear 0% 0 0 / 0.5)", "color(srgb-linear 0 0 0 / 0.5)", + "color(srgb-linear 20% 0 10/0.5)", "color(srgb-linear 0.2 0 10 / 0.5)", + "color(srgb-linear 20% 0 10/50%)", "color(srgb-linear 0.2 0 10 / 0.5)", + "color(srgb-linear 400% 0 10/50%)", "color(srgb-linear 4 0 10 / 0.5)", + "color(srgb-linear 50% -160 160)", "color(srgb-linear 0.5 -160 160)", + "color(srgb-linear 50% -200 200)", "color(srgb-linear 0.5 -200 200)", + "color(srgb-linear 0 0 0 / -10%)", "color(srgb-linear 0 0 0 / 0)", + "color(srgb-linear 0 0 0 / 110%)", "color(srgb-linear 0 0 0)", + "color(srgb-linear 0 0 0 / 300%)", "color(srgb-linear 0 0 0)", + "color(srgb-linear 200 200 200)", "color(srgb-linear 200 200 200)", + "color(srgb-linear 200 200 200 / 200)", "color(srgb-linear 200 200 200)", + "color(srgb-linear -200 -200 -200)", "color(srgb-linear -200 -200 -200)", + "color(srgb-linear -200 -200 -200 / -200)", "color(srgb-linear -200 -200 -200 / 0)", + "color(srgb-linear 200% 200% 200%)", "color(srgb-linear 2 2 2)", + "color(srgb-linear 200% 200% 200% / 200%)", "color(srgb-linear 2 2 2)", + "color(srgb-linear -200% -200% -200% / -200%)", "color(srgb-linear -2 -2 -2 / 0)", + "color(display-p3 0% 0% 0%)", "color(display-p3 0 0 0)", + "color(display-p3 10% 10% 10%)", "color(display-p3 0.1 0.1 0.1)", + "color(display-p3 .2 .2 25%)", "color(display-p3 0.2 0.2 0.25)", + "color(display-p3 0 0 0 / 1)", "color(display-p3 0 0 0)", + "color(display-p3 0% 0 0 / 0.5)", "color(display-p3 0 0 0 / 0.5)", + "color(display-p3 20% 0 10/0.5)", "color(display-p3 0.2 0 10 / 0.5)", + "color(display-p3 20% 0 10/50%)", "color(display-p3 0.2 0 10 / 0.5)", + "color(display-p3 400% 0 10/50%)", "color(display-p3 4 0 10 / 0.5)", + "color(display-p3 50% -160 160)", "color(display-p3 0.5 -160 160)", + "color(display-p3 50% -200 200)", "color(display-p3 0.5 -200 200)", + "color(display-p3 0 0 0 / -10%)", "color(display-p3 0 0 0 / 0)", + "color(display-p3 0 0 0 / 110%)", "color(display-p3 0 0 0)", + "color(display-p3 0 0 0 / 300%)", "color(display-p3 0 0 0)", + "color(display-p3 200 200 200)", "color(display-p3 200 200 200)", + "color(display-p3 200 200 200 / 200)", "color(display-p3 200 200 200)", + "color(display-p3 -200 -200 -200)", "color(display-p3 -200 -200 -200)", + "color(display-p3 -200 -200 -200 / -200)", "color(display-p3 -200 -200 -200 / 0)", + "color(display-p3 200% 200% 200%)", "color(display-p3 2 2 2)", + "color(display-p3 200% 200% 200% / 200%)", "color(display-p3 2 2 2)", + "color(display-p3 -200% -200% -200% / -200%)", "color(display-p3 -2 -2 -2 / 0)", + "color(a98-rgb 0% 0% 0%)", "color(a98-rgb 0 0 0)", + "color(a98-rgb 10% 10% 10%)", "color(a98-rgb 0.1 0.1 0.1)", + "color(a98-rgb .2 .2 25%)", "color(a98-rgb 0.2 0.2 0.25)", + "color(a98-rgb 0 0 0 / 1)", "color(a98-rgb 0 0 0)", + "color(a98-rgb 0% 0 0 / 0.5)", "color(a98-rgb 0 0 0 / 0.5)", + "color(a98-rgb 20% 0 10/0.5)", "color(a98-rgb 0.2 0 10 / 0.5)", + "color(a98-rgb 20% 0 10/50%)", "color(a98-rgb 0.2 0 10 / 0.5)", + "color(a98-rgb 400% 0 10/50%)", "color(a98-rgb 4 0 10 / 0.5)", + "color(a98-rgb 50% -160 160)", "color(a98-rgb 0.5 -160 160)", + "color(a98-rgb 50% -200 200)", "color(a98-rgb 0.5 -200 200)", + "color(a98-rgb 0 0 0 / -10%)", "color(a98-rgb 0 0 0 / 0)", + "color(a98-rgb 0 0 0 / 110%)", "color(a98-rgb 0 0 0)", + "color(a98-rgb 0 0 0 / 300%)", "color(a98-rgb 0 0 0)", + "color(a98-rgb 200 200 200)", "color(a98-rgb 200 200 200)", + "color(a98-rgb 200 200 200 / 200)", "color(a98-rgb 200 200 200)", + "color(a98-rgb -200 -200 -200)", "color(a98-rgb -200 -200 -200)", + "color(a98-rgb -200 -200 -200 / -200)", "color(a98-rgb -200 -200 -200 / 0)", + "color(a98-rgb 200% 200% 200%)", "color(a98-rgb 2 2 2)", + "color(a98-rgb 200% 200% 200% / 200%)", "color(a98-rgb 2 2 2)", + "color(a98-rgb -200% -200% -200% / -200%)", "color(a98-rgb -2 -2 -2 / 0)", + "color(prophoto-rgb 0% 0% 0%)", "color(prophoto-rgb 0 0 0)", + "color(prophoto-rgb 10% 10% 10%)", "color(prophoto-rgb 0.1 0.1 0.1)", + "color(prophoto-rgb .2 .2 25%)", "color(prophoto-rgb 0.2 0.2 0.25)", + "color(prophoto-rgb 0 0 0 / 1)", "color(prophoto-rgb 0 0 0)", + "color(prophoto-rgb 0% 0 0 / 0.5)", "color(prophoto-rgb 0 0 0 / 0.5)", + "color(prophoto-rgb 20% 0 10/0.5)", "color(prophoto-rgb 0.2 0 10 / 0.5)", + "color(prophoto-rgb 20% 0 10/50%)", "color(prophoto-rgb 0.2 0 10 / 0.5)", + "color(prophoto-rgb 400% 0 10/50%)", "color(prophoto-rgb 4 0 10 / 0.5)", + "color(prophoto-rgb 50% -160 160)", "color(prophoto-rgb 0.5 -160 160)", + "color(prophoto-rgb 50% -200 200)", "color(prophoto-rgb 0.5 -200 200)", + "color(prophoto-rgb 0 0 0 / -10%)", "color(prophoto-rgb 0 0 0 / 0)", + "color(prophoto-rgb 0 0 0 / 110%)", "color(prophoto-rgb 0 0 0)", + "color(prophoto-rgb 0 0 0 / 300%)", "color(prophoto-rgb 0 0 0)", + "color(prophoto-rgb 200 200 200)", "color(prophoto-rgb 200 200 200)", + "color(prophoto-rgb 200 200 200 / 200)", "color(prophoto-rgb 200 200 200)", + "color(prophoto-rgb -200 -200 -200)", "color(prophoto-rgb -200 -200 -200)", + "color(prophoto-rgb -200 -200 -200 / -200)", "color(prophoto-rgb -200 -200 -200 / 0)", + "color(prophoto-rgb 200% 200% 200%)", "color(prophoto-rgb 2 2 2)", + "color(prophoto-rgb 200% 200% 200% / 200%)", "color(prophoto-rgb 2 2 2)", + "color(prophoto-rgb -200% -200% -200% / -200%)", "color(prophoto-rgb -2 -2 -2 / 0)", + "color(rec2020 0% 0% 0%)", "color(rec2020 0 0 0)", + "color(rec2020 10% 10% 10%)", "color(rec2020 0.1 0.1 0.1)", + "color(rec2020 .2 .2 25%)", "color(rec2020 0.2 0.2 0.25)", + "color(rec2020 0 0 0 / 1)", "color(rec2020 0 0 0)", + "color(rec2020 0% 0 0 / 0.5)", "color(rec2020 0 0 0 / 0.5)", + "color(rec2020 20% 0 10/0.5)", "color(rec2020 0.2 0 10 / 0.5)", + "color(rec2020 20% 0 10/50%)", "color(rec2020 0.2 0 10 / 0.5)", + "color(rec2020 400% 0 10/50%)", "color(rec2020 4 0 10 / 0.5)", + "color(rec2020 50% -160 160)", "color(rec2020 0.5 -160 160)", + "color(rec2020 50% -200 200)", "color(rec2020 0.5 -200 200)", + "color(rec2020 0 0 0 / -10%)", "color(rec2020 0 0 0 / 0)", + "color(rec2020 0 0 0 / 110%)", "color(rec2020 0 0 0)", + "color(rec2020 0 0 0 / 300%)", "color(rec2020 0 0 0)", + "color(rec2020 200 200 200)", "color(rec2020 200 200 200)", + "color(rec2020 200 200 200 / 200)", "color(rec2020 200 200 200)", + "color(rec2020 -200 -200 -200)", "color(rec2020 -200 -200 -200)", + "color(rec2020 -200 -200 -200 / -200)", "color(rec2020 -200 -200 -200 / 0)", + "color(rec2020 200% 200% 200%)", "color(rec2020 2 2 2)", + "color(rec2020 200% 200% 200% / 200%)", "color(rec2020 2 2 2)", + "color(rec2020 -200% -200% -200% / -200%)", "color(rec2020 -2 -2 -2 / 0)", + "color(xyz 0% 0% 0%)", "color(xyz-d65 0 0 0)", + "color(xyz 10% 10% 10%)", "color(xyz-d65 0.1 0.1 0.1)", + "color(xyz .2 .2 25%)", "color(xyz-d65 0.2 0.2 0.25)", + "color(xyz 0 0 0 / 1)", "color(xyz-d65 0 0 0)", + "color(xyz 0% 0 0 / 0.5)", "color(xyz-d65 0 0 0 / 0.5)", + "color(xyz 20% 0 10/0.5)", "color(xyz-d65 0.2 0 10 / 0.5)", + "color(xyz 20% 0 10/50%)", "color(xyz-d65 0.2 0 10 / 0.5)", + "color(xyz 400% 0 10/50%)", "color(xyz-d65 4 0 10 / 0.5)", + "color(xyz 50% -160 160)", "color(xyz-d65 0.5 -160 160)", + "color(xyz 50% -200 200)", "color(xyz-d65 0.5 -200 200)", + "color(xyz 0 0 0 / -10%)", "color(xyz-d65 0 0 0 / 0)", + "color(xyz 0 0 0 / 110%)", "color(xyz-d65 0 0 0)", + "color(xyz 0 0 0 / 300%)", "color(xyz-d65 0 0 0)", + "color(xyz 200 200 200)", "color(xyz-d65 200 200 200)", + "color(xyz 200 200 200 / 200)", "color(xyz-d65 200 200 200)", + "color(xyz -200 -200 -200)", "color(xyz-d65 -200 -200 -200)", + "color(xyz -200 -200 -200 / -200)", "color(xyz-d65 -200 -200 -200 / 0)", + "color(xyz 200% 200% 200%)", "color(xyz-d65 2 2 2)", + "color(xyz 200% 200% 200% / 200%)", "color(xyz-d65 2 2 2)", + "color(xyz -200% -200% -200% / -200%)", "color(xyz-d65 -2 -2 -2 / 0)", + "color(xyz-d50 0% 0% 0%)", "color(xyz-d50 0 0 0)", + "color(xyz-d50 10% 10% 10%)", "color(xyz-d50 0.1 0.1 0.1)", + "color(xyz-d50 .2 .2 25%)", "color(xyz-d50 0.2 0.2 0.25)", + "color(xyz-d50 0 0 0 / 1)", "color(xyz-d50 0 0 0)", + "color(xyz-d50 0% 0 0 / 0.5)", "color(xyz-d50 0 0 0 / 0.5)", + "color(xyz-d50 20% 0 10/0.5)", "color(xyz-d50 0.2 0 10 / 0.5)", + "color(xyz-d50 20% 0 10/50%)", "color(xyz-d50 0.2 0 10 / 0.5)", + "color(xyz-d50 400% 0 10/50%)", "color(xyz-d50 4 0 10 / 0.5)", + "color(xyz-d50 50% -160 160)", "color(xyz-d50 0.5 -160 160)", + "color(xyz-d50 50% -200 200)", "color(xyz-d50 0.5 -200 200)", + "color(xyz-d50 0 0 0 / -10%)", "color(xyz-d50 0 0 0 / 0)", + "color(xyz-d50 0 0 0 / 110%)", "color(xyz-d50 0 0 0)", + "color(xyz-d50 0 0 0 / 300%)", "color(xyz-d50 0 0 0)", + "color(xyz-d50 200 200 200)", "color(xyz-d50 200 200 200)", + "color(xyz-d50 200 200 200 / 200)", "color(xyz-d50 200 200 200)", + "color(xyz-d50 -200 -200 -200)", "color(xyz-d50 -200 -200 -200)", + "color(xyz-d50 -200 -200 -200 / -200)", "color(xyz-d50 -200 -200 -200 / 0)", + "color(xyz-d50 200% 200% 200%)", "color(xyz-d50 2 2 2)", + "color(xyz-d50 200% 200% 200% / 200%)", "color(xyz-d50 2 2 2)", + "color(xyz-d50 -200% -200% -200% / -200%)", "color(xyz-d50 -2 -2 -2 / 0)", + "color(xyz-d65 0% 0% 0%)", "color(xyz-d65 0 0 0)", + "color(xyz-d65 10% 10% 10%)", "color(xyz-d65 0.1 0.1 0.1)", + "color(xyz-d65 .2 .2 25%)", "color(xyz-d65 0.2 0.2 0.25)", + "color(xyz-d65 0 0 0 / 1)", "color(xyz-d65 0 0 0)", + "color(xyz-d65 0% 0 0 / 0.5)", "color(xyz-d65 0 0 0 / 0.5)", + "color(xyz-d65 20% 0 10/0.5)", "color(xyz-d65 0.2 0 10 / 0.5)", + "color(xyz-d65 20% 0 10/50%)", "color(xyz-d65 0.2 0 10 / 0.5)", + "color(xyz-d65 400% 0 10/50%)", "color(xyz-d65 4 0 10 / 0.5)", + "color(xyz-d65 50% -160 160)", "color(xyz-d65 0.5 -160 160)", + "color(xyz-d65 50% -200 200)", "color(xyz-d65 0.5 -200 200)", + "color(xyz-d65 0 0 0 / -10%)", "color(xyz-d65 0 0 0 / 0)", + "color(xyz-d65 0 0 0 / 110%)", "color(xyz-d65 0 0 0)", + "color(xyz-d65 0 0 0 / 300%)", "color(xyz-d65 0 0 0)", + "color(xyz-d65 200 200 200)", "color(xyz-d65 200 200 200)", + "color(xyz-d65 200 200 200 / 200)", "color(xyz-d65 200 200 200)", + "color(xyz-d65 -200 -200 -200)", "color(xyz-d65 -200 -200 -200)", + "color(xyz-d65 -200 -200 -200 / -200)", "color(xyz-d65 -200 -200 -200 / 0)", + "color(xyz-d65 200% 200% 200%)", "color(xyz-d65 2 2 2)", + "color(xyz-d65 200% 200% 200% / 200%)", "color(xyz-d65 2 2 2)", + "color(xyz-d65 -200% -200% -200% / -200%)", "color(xyz-d65 -2 -2 -2 / 0)" +]
diff --git a/src/css-parsing-tests/color4_hwb.json b/src/css-parsing-tests/color4_hwb.json new file mode 100644 index 0000000..794c68b --- /dev/null +++ b/src/css-parsing-tests/color4_hwb.json
@@ -0,0 +1,7778 @@ +[ +"hwb(0deg 0% 0%)", "rgb(255, 0, 0)", +"hwb(0 0% 0%)", "rgb(255, 0, 0)", +"hwb(0deg 0% 0% / 0)", "rgba(255, 0, 0, 0)", +"hwb(0 0% 0% / 0)", "rgba(255, 0, 0, 0)", +"hwb(0deg 0% 0% / 0.2)", "rgba(255, 0, 0, 0.2)", +"hwb(0 0% 0% / 0.2)", "rgba(255, 0, 0, 0.2)", +"hwb(0deg 0% 0% / 1)", "rgb(255, 0, 0)", +"hwb(0 0% 0% / 1)", "rgb(255, 0, 0)", +"hwb(0deg 0% 12.5%)", "rgb(223, 0, 0)", +"hwb(0 0% 12.5%)", "rgb(223, 0, 0)", +"hwb(0deg 0% 12.5% / 0)", "rgba(223, 0, 0, 0)", +"hwb(0 0% 12.5% / 0)", "rgba(223, 0, 0, 0)", +"hwb(0deg 0% 12.5% / 0.2)", "rgba(223, 0, 0, 0.2)", +"hwb(0 0% 12.5% / 0.2)", "rgba(223, 0, 0, 0.2)", +"hwb(0deg 0% 12.5% / 1)", "rgb(223, 0, 0)", +"hwb(0 0% 12.5% / 1)", "rgb(223, 0, 0)", +"hwb(0deg 0% 25%)", "rgb(191, 0, 0)", +"hwb(0 0% 25%)", "rgb(191, 0, 0)", +"hwb(0deg 0% 25% / 0)", "rgba(191, 0, 0, 0)", +"hwb(0 0% 25% / 0)", "rgba(191, 0, 0, 0)", +"hwb(0deg 0% 25% / 0.2)", "rgba(191, 0, 0, 0.2)", +"hwb(0 0% 25% / 0.2)", "rgba(191, 0, 0, 0.2)", +"hwb(0deg 0% 25% / 1)", "rgb(191, 0, 0)", +"hwb(0 0% 25% / 1)", "rgb(191, 0, 0)", +"hwb(0deg 0% 37.5%)", "rgb(159, 0, 0)", +"hwb(0 0% 37.5%)", "rgb(159, 0, 0)", +"hwb(0deg 0% 37.5% / 0)", "rgba(159, 0, 0, 0)", +"hwb(0 0% 37.5% / 0)", "rgba(159, 0, 0, 0)", +"hwb(0deg 0% 37.5% / 0.2)", "rgba(159, 0, 0, 0.2)", +"hwb(0 0% 37.5% / 0.2)", "rgba(159, 0, 0, 0.2)", +"hwb(0deg 0% 37.5% / 1)", "rgb(159, 0, 0)", +"hwb(0 0% 37.5% / 1)", "rgb(159, 0, 0)", +"hwb(0deg 0% 50%)", "rgb(128, 0, 0)", +"hwb(0 0% 50%)", "rgb(128, 0, 0)", +"hwb(0deg 0% 50% / 0)", "rgba(128, 0, 0, 0)", +"hwb(0 0% 50% / 0)", "rgba(128, 0, 0, 0)", +"hwb(0deg 0% 50% / 0.2)", "rgba(128, 0, 0, 0.2)", +"hwb(0 0% 50% / 0.2)", "rgba(128, 0, 0, 0.2)", +"hwb(0deg 0% 50% / 1)", "rgb(128, 0, 0)", +"hwb(0 0% 50% / 1)", "rgb(128, 0, 0)", +"hwb(0deg 0% 62.5%)", "rgb(96, 0, 0)", +"hwb(0 0% 62.5%)", "rgb(96, 0, 0)", +"hwb(0deg 0% 62.5% / 0)", "rgba(96, 0, 0, 0)", +"hwb(0 0% 62.5% / 0)", "rgba(96, 0, 0, 0)", +"hwb(0deg 0% 62.5% / 0.2)", "rgba(96, 0, 0, 0.2)", +"hwb(0 0% 62.5% / 0.2)", "rgba(96, 0, 0, 0.2)", +"hwb(0deg 0% 62.5% / 1)", "rgb(96, 0, 0)", +"hwb(0 0% 62.5% / 1)", "rgb(96, 0, 0)", +"hwb(0deg 0% 75%)", "rgb(64, 0, 0)", +"hwb(0 0% 75%)", "rgb(64, 0, 0)", +"hwb(0deg 0% 75% / 0)", "rgba(64, 0, 0, 0)", +"hwb(0 0% 75% / 0)", "rgba(64, 0, 0, 0)", +"hwb(0deg 0% 75% / 0.2)", "rgba(64, 0, 0, 0.2)", +"hwb(0 0% 75% / 0.2)", "rgba(64, 0, 0, 0.2)", +"hwb(0deg 0% 75% / 1)", "rgb(64, 0, 0)", +"hwb(0 0% 75% / 1)", "rgb(64, 0, 0)", +"hwb(0deg 0% 87.5%)", "rgb(32, 0, 0)", +"hwb(0 0% 87.5%)", "rgb(32, 0, 0)", +"hwb(0deg 0% 87.5% / 0)", "rgba(32, 0, 0, 0)", +"hwb(0 0% 87.5% / 0)", "rgba(32, 0, 0, 0)", +"hwb(0deg 0% 87.5% / 0.2)", "rgba(32, 0, 0, 0.2)", +"hwb(0 0% 87.5% / 0.2)", "rgba(32, 0, 0, 0.2)", +"hwb(0deg 0% 87.5% / 1)", "rgb(32, 0, 0)", +"hwb(0 0% 87.5% / 1)", "rgb(32, 0, 0)", +"hwb(0deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(0 0% 100%)", "rgb(0, 0, 0)", +"hwb(0deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(0 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(0deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(0 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(0deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(0 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(0deg 12.5% 0%)", "rgb(255, 32, 32)", +"hwb(0 12.5% 0%)", "rgb(255, 32, 32)", +"hwb(0deg 12.5% 0% / 0)", "rgba(255, 32, 32, 0)", +"hwb(0 12.5% 0% / 0)", "rgba(255, 32, 32, 0)", +"hwb(0deg 12.5% 0% / 0.2)", "rgba(255, 32, 32, 0.2)", +"hwb(0 12.5% 0% / 0.2)", "rgba(255, 32, 32, 0.2)", +"hwb(0deg 12.5% 0% / 1)", "rgb(255, 32, 32)", +"hwb(0 12.5% 0% / 1)", "rgb(255, 32, 32)", +"hwb(0deg 12.5% 12.5%)", "rgb(223, 32, 32)", +"hwb(0 12.5% 12.5%)", "rgb(223, 32, 32)", +"hwb(0deg 12.5% 12.5% / 0)", "rgba(223, 32, 32, 0)", +"hwb(0 12.5% 12.5% / 0)", "rgba(223, 32, 32, 0)", +"hwb(0deg 12.5% 12.5% / 0.2)", "rgba(223, 32, 32, 0.2)", +"hwb(0 12.5% 12.5% / 0.2)", "rgba(223, 32, 32, 0.2)", +"hwb(0deg 12.5% 12.5% / 1)", "rgb(223, 32, 32)", +"hwb(0 12.5% 12.5% / 1)", "rgb(223, 32, 32)", +"hwb(0deg 12.5% 25%)", "rgb(191, 32, 32)", +"hwb(0 12.5% 25%)", "rgb(191, 32, 32)", +"hwb(0deg 12.5% 25% / 0)", "rgba(191, 32, 32, 0)", +"hwb(0 12.5% 25% / 0)", "rgba(191, 32, 32, 0)", +"hwb(0deg 12.5% 25% / 0.2)", "rgba(191, 32, 32, 0.2)", +"hwb(0 12.5% 25% / 0.2)", "rgba(191, 32, 32, 0.2)", +"hwb(0deg 12.5% 25% / 1)", "rgb(191, 32, 32)", +"hwb(0 12.5% 25% / 1)", "rgb(191, 32, 32)", +"hwb(0deg 12.5% 37.5%)", "rgb(159, 32, 32)", +"hwb(0 12.5% 37.5%)", "rgb(159, 32, 32)", +"hwb(0deg 12.5% 37.5% / 0)", "rgba(159, 32, 32, 0)", +"hwb(0 12.5% 37.5% / 0)", "rgba(159, 32, 32, 0)", +"hwb(0deg 12.5% 37.5% / 0.2)", "rgba(159, 32, 32, 0.2)", +"hwb(0 12.5% 37.5% / 0.2)", "rgba(159, 32, 32, 0.2)", +"hwb(0deg 12.5% 37.5% / 1)", "rgb(159, 32, 32)", +"hwb(0 12.5% 37.5% / 1)", "rgb(159, 32, 32)", +"hwb(0deg 12.5% 50%)", "rgb(128, 32, 32)", +"hwb(0 12.5% 50%)", "rgb(128, 32, 32)", +"hwb(0deg 12.5% 50% / 0)", "rgba(128, 32, 32, 0)", +"hwb(0 12.5% 50% / 0)", "rgba(128, 32, 32, 0)", +"hwb(0deg 12.5% 50% / 0.2)", "rgba(128, 32, 32, 0.2)", +"hwb(0 12.5% 50% / 0.2)", "rgba(128, 32, 32, 0.2)", +"hwb(0deg 12.5% 50% / 1)", "rgb(128, 32, 32)", +"hwb(0 12.5% 50% / 1)", "rgb(128, 32, 32)", +"hwb(0deg 12.5% 62.5%)", "rgb(96, 32, 32)", +"hwb(0 12.5% 62.5%)", "rgb(96, 32, 32)", +"hwb(0deg 12.5% 62.5% / 0)", "rgba(96, 32, 32, 0)", +"hwb(0 12.5% 62.5% / 0)", "rgba(96, 32, 32, 0)", +"hwb(0deg 12.5% 62.5% / 0.2)", "rgba(96, 32, 32, 0.2)", +"hwb(0 12.5% 62.5% / 0.2)", "rgba(96, 32, 32, 0.2)", +"hwb(0deg 12.5% 62.5% / 1)", "rgb(96, 32, 32)", +"hwb(0 12.5% 62.5% / 1)", "rgb(96, 32, 32)", +"hwb(0deg 12.5% 75%)", "rgb(64, 32, 32)", +"hwb(0 12.5% 75%)", "rgb(64, 32, 32)", +"hwb(0deg 12.5% 75% / 0)", "rgba(64, 32, 32, 0)", +"hwb(0 12.5% 75% / 0)", "rgba(64, 32, 32, 0)", +"hwb(0deg 12.5% 75% / 0.2)", "rgba(64, 32, 32, 0.2)", +"hwb(0 12.5% 75% / 0.2)", "rgba(64, 32, 32, 0.2)", +"hwb(0deg 12.5% 75% / 1)", "rgb(64, 32, 32)", +"hwb(0 12.5% 75% / 1)", "rgb(64, 32, 32)", +"hwb(0deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(0 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(0deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(0 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(0deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(0 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(0deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(0 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(0deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(0 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(0deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(0 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(0deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(0 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(0deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(0 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(0deg 25% 0%)", "rgb(255, 64, 64)", +"hwb(0 25% 0%)", "rgb(255, 64, 64)", +"hwb(0deg 25% 0% / 0)", "rgba(255, 64, 64, 0)", +"hwb(0 25% 0% / 0)", "rgba(255, 64, 64, 0)", +"hwb(0deg 25% 0% / 0.2)", "rgba(255, 64, 64, 0.2)", +"hwb(0 25% 0% / 0.2)", "rgba(255, 64, 64, 0.2)", +"hwb(0deg 25% 0% / 1)", "rgb(255, 64, 64)", +"hwb(0 25% 0% / 1)", "rgb(255, 64, 64)", +"hwb(0deg 25% 12.5%)", "rgb(223, 64, 64)", +"hwb(0 25% 12.5%)", "rgb(223, 64, 64)", +"hwb(0deg 25% 12.5% / 0)", "rgba(223, 64, 64, 0)", +"hwb(0 25% 12.5% / 0)", "rgba(223, 64, 64, 0)", +"hwb(0deg 25% 12.5% / 0.2)", "rgba(223, 64, 64, 0.2)", +"hwb(0 25% 12.5% / 0.2)", "rgba(223, 64, 64, 0.2)", +"hwb(0deg 25% 12.5% / 1)", "rgb(223, 64, 64)", +"hwb(0 25% 12.5% / 1)", "rgb(223, 64, 64)", +"hwb(0deg 25% 25%)", "rgb(191, 64, 64)", +"hwb(0 25% 25%)", "rgb(191, 64, 64)", +"hwb(0deg 25% 25% / 0)", "rgba(191, 64, 64, 0)", +"hwb(0 25% 25% / 0)", "rgba(191, 64, 64, 0)", +"hwb(0deg 25% 25% / 0.2)", "rgba(191, 64, 64, 0.2)", +"hwb(0 25% 25% / 0.2)", "rgba(191, 64, 64, 0.2)", +"hwb(0deg 25% 25% / 1)", "rgb(191, 64, 64)", +"hwb(0 25% 25% / 1)", "rgb(191, 64, 64)", +"hwb(0deg 25% 37.5%)", "rgb(159, 64, 64)", +"hwb(0 25% 37.5%)", "rgb(159, 64, 64)", +"hwb(0deg 25% 37.5% / 0)", "rgba(159, 64, 64, 0)", +"hwb(0 25% 37.5% / 0)", "rgba(159, 64, 64, 0)", +"hwb(0deg 25% 37.5% / 0.2)", "rgba(159, 64, 64, 0.2)", +"hwb(0 25% 37.5% / 0.2)", "rgba(159, 64, 64, 0.2)", +"hwb(0deg 25% 37.5% / 1)", "rgb(159, 64, 64)", +"hwb(0 25% 37.5% / 1)", "rgb(159, 64, 64)", +"hwb(0deg 25% 50%)", "rgb(128, 64, 64)", +"hwb(0 25% 50%)", "rgb(128, 64, 64)", +"hwb(0deg 25% 50% / 0)", "rgba(128, 64, 64, 0)", +"hwb(0 25% 50% / 0)", "rgba(128, 64, 64, 0)", +"hwb(0deg 25% 50% / 0.2)", "rgba(128, 64, 64, 0.2)", +"hwb(0 25% 50% / 0.2)", "rgba(128, 64, 64, 0.2)", +"hwb(0deg 25% 50% / 1)", "rgb(128, 64, 64)", +"hwb(0 25% 50% / 1)", "rgb(128, 64, 64)", +"hwb(0deg 25% 62.5%)", "rgb(96, 64, 64)", +"hwb(0 25% 62.5%)", "rgb(96, 64, 64)", +"hwb(0deg 25% 62.5% / 0)", "rgba(96, 64, 64, 0)", +"hwb(0 25% 62.5% / 0)", "rgba(96, 64, 64, 0)", +"hwb(0deg 25% 62.5% / 0.2)", "rgba(96, 64, 64, 0.2)", +"hwb(0 25% 62.5% / 0.2)", "rgba(96, 64, 64, 0.2)", +"hwb(0deg 25% 62.5% / 1)", "rgb(96, 64, 64)", +"hwb(0 25% 62.5% / 1)", "rgb(96, 64, 64)", +"hwb(0deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(0 25% 75%)", "rgb(64, 64, 64)", +"hwb(0deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(0 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(0deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(0 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(0deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(0 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(0deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(0 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(0deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(0 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(0deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(0 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(0deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(0 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(0deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(0 25% 100%)", "rgb(51, 51, 51)", +"hwb(0deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(0 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(0deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(0 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(0deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(0 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(0deg 37.5% 0%)", "rgb(255, 96, 96)", +"hwb(0 37.5% 0%)", "rgb(255, 96, 96)", +"hwb(0deg 37.5% 0% / 0)", "rgba(255, 96, 96, 0)", +"hwb(0 37.5% 0% / 0)", "rgba(255, 96, 96, 0)", +"hwb(0deg 37.5% 0% / 0.2)", "rgba(255, 96, 96, 0.2)", +"hwb(0 37.5% 0% / 0.2)", "rgba(255, 96, 96, 0.2)", +"hwb(0deg 37.5% 0% / 1)", "rgb(255, 96, 96)", +"hwb(0 37.5% 0% / 1)", "rgb(255, 96, 96)", +"hwb(0deg 37.5% 12.5%)", "rgb(223, 96, 96)", +"hwb(0 37.5% 12.5%)", "rgb(223, 96, 96)", +"hwb(0deg 37.5% 12.5% / 0)", "rgba(223, 96, 96, 0)", +"hwb(0 37.5% 12.5% / 0)", "rgba(223, 96, 96, 0)", +"hwb(0deg 37.5% 12.5% / 0.2)", "rgba(223, 96, 96, 0.2)", +"hwb(0 37.5% 12.5% / 0.2)", "rgba(223, 96, 96, 0.2)", +"hwb(0deg 37.5% 12.5% / 1)", "rgb(223, 96, 96)", +"hwb(0 37.5% 12.5% / 1)", "rgb(223, 96, 96)", +"hwb(0deg 37.5% 25%)", "rgb(191, 96, 96)", +"hwb(0 37.5% 25%)", "rgb(191, 96, 96)", +"hwb(0deg 37.5% 25% / 0)", "rgba(191, 96, 96, 0)", +"hwb(0 37.5% 25% / 0)", "rgba(191, 96, 96, 0)", +"hwb(0deg 37.5% 25% / 0.2)", "rgba(191, 96, 96, 0.2)", +"hwb(0 37.5% 25% / 0.2)", "rgba(191, 96, 96, 0.2)", +"hwb(0deg 37.5% 25% / 1)", "rgb(191, 96, 96)", +"hwb(0 37.5% 25% / 1)", "rgb(191, 96, 96)", +"hwb(0deg 37.5% 37.5%)", "rgb(159, 96, 96)", +"hwb(0 37.5% 37.5%)", "rgb(159, 96, 96)", +"hwb(0deg 37.5% 37.5% / 0)", "rgba(159, 96, 96, 0)", +"hwb(0 37.5% 37.5% / 0)", "rgba(159, 96, 96, 0)", +"hwb(0deg 37.5% 37.5% / 0.2)", "rgba(159, 96, 96, 0.2)", +"hwb(0 37.5% 37.5% / 0.2)", "rgba(159, 96, 96, 0.2)", +"hwb(0deg 37.5% 37.5% / 1)", "rgb(159, 96, 96)", +"hwb(0 37.5% 37.5% / 1)", "rgb(159, 96, 96)", +"hwb(0deg 37.5% 50%)", "rgb(128, 96, 96)", +"hwb(0 37.5% 50%)", "rgb(128, 96, 96)", +"hwb(0deg 37.5% 50% / 0)", "rgba(128, 96, 96, 0)", +"hwb(0 37.5% 50% / 0)", "rgba(128, 96, 96, 0)", +"hwb(0deg 37.5% 50% / 0.2)", "rgba(128, 96, 96, 0.2)", +"hwb(0 37.5% 50% / 0.2)", "rgba(128, 96, 96, 0.2)", +"hwb(0deg 37.5% 50% / 1)", "rgb(128, 96, 96)", +"hwb(0 37.5% 50% / 1)", "rgb(128, 96, 96)", +"hwb(0deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(0 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(0deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(0 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(0deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(0 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(0deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(0 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(0deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(0 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(0deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(0 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(0deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(0 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(0deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(0 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(0deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(0 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(0deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(0 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(0deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(0 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(0deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(0 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(0deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(0 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(0deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(0 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(0deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(0 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(0deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(0 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(0deg 50% 0%)", "rgb(255, 128, 128)", +"hwb(0 50% 0%)", "rgb(255, 128, 128)", +"hwb(0deg 50% 0% / 0)", "rgba(255, 128, 128, 0)", +"hwb(0 50% 0% / 0)", "rgba(255, 128, 128, 0)", +"hwb(0deg 50% 0% / 0.2)", "rgba(255, 128, 128, 0.2)", +"hwb(0 50% 0% / 0.2)", "rgba(255, 128, 128, 0.2)", +"hwb(0deg 50% 0% / 1)", "rgb(255, 128, 128)", +"hwb(0 50% 0% / 1)", "rgb(255, 128, 128)", +"hwb(0deg 50% 12.5%)", "rgb(223, 128, 128)", +"hwb(0 50% 12.5%)", "rgb(223, 128, 128)", +"hwb(0deg 50% 12.5% / 0)", "rgba(223, 128, 128, 0)", +"hwb(0 50% 12.5% / 0)", "rgba(223, 128, 128, 0)", +"hwb(0deg 50% 12.5% / 0.2)", "rgba(223, 128, 128, 0.2)", +"hwb(0 50% 12.5% / 0.2)", "rgba(223, 128, 128, 0.2)", +"hwb(0deg 50% 12.5% / 1)", "rgb(223, 128, 128)", +"hwb(0 50% 12.5% / 1)", "rgb(223, 128, 128)", +"hwb(0deg 50% 25%)", "rgb(191, 128, 128)", +"hwb(0 50% 25%)", "rgb(191, 128, 128)", +"hwb(0deg 50% 25% / 0)", "rgba(191, 128, 128, 0)", +"hwb(0 50% 25% / 0)", "rgba(191, 128, 128, 0)", +"hwb(0deg 50% 25% / 0.2)", "rgba(191, 128, 128, 0.2)", +"hwb(0 50% 25% / 0.2)", "rgba(191, 128, 128, 0.2)", +"hwb(0deg 50% 25% / 1)", "rgb(191, 128, 128)", +"hwb(0 50% 25% / 1)", "rgb(191, 128, 128)", +"hwb(0deg 50% 37.5%)", "rgb(159, 128, 128)", +"hwb(0 50% 37.5%)", "rgb(159, 128, 128)", +"hwb(0deg 50% 37.5% / 0)", "rgba(159, 128, 128, 0)", +"hwb(0 50% 37.5% / 0)", "rgba(159, 128, 128, 0)", +"hwb(0deg 50% 37.5% / 0.2)", "rgba(159, 128, 128, 0.2)", +"hwb(0 50% 37.5% / 0.2)", "rgba(159, 128, 128, 0.2)", +"hwb(0deg 50% 37.5% / 1)", "rgb(159, 128, 128)", +"hwb(0 50% 37.5% / 1)", "rgb(159, 128, 128)", +"hwb(0deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(0 50% 50%)", "rgb(128, 128, 128)", +"hwb(0deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(0 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(0deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(0 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(0deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(0 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(0deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(0 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(0deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(0 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(0deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(0 50% 75%)", "rgb(102, 102, 102)", +"hwb(0deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(0 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(0deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(0 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(0deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(0 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(0deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(0 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(0deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(0 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(0deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(0 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(0deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(0 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(0deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(0 50% 100%)", "rgb(85, 85, 85)", +"hwb(0deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(0 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(0deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(0 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(0deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(0 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(0deg 62.5% 0%)", "rgb(255, 159, 159)", +"hwb(0 62.5% 0%)", "rgb(255, 159, 159)", +"hwb(0deg 62.5% 0% / 0)", "rgba(255, 159, 159, 0)", +"hwb(0 62.5% 0% / 0)", "rgba(255, 159, 159, 0)", +"hwb(0deg 62.5% 0% / 0.2)", "rgba(255, 159, 159, 0.2)", +"hwb(0 62.5% 0% / 0.2)", "rgba(255, 159, 159, 0.2)", +"hwb(0deg 62.5% 0% / 1)", "rgb(255, 159, 159)", +"hwb(0 62.5% 0% / 1)", "rgb(255, 159, 159)", +"hwb(0deg 62.5% 12.5%)", "rgb(223, 159, 159)", +"hwb(0 62.5% 12.5%)", "rgb(223, 159, 159)", +"hwb(0deg 62.5% 12.5% / 0)", "rgba(223, 159, 159, 0)", +"hwb(0 62.5% 12.5% / 0)", "rgba(223, 159, 159, 0)", +"hwb(0deg 62.5% 12.5% / 0.2)", "rgba(223, 159, 159, 0.2)", +"hwb(0 62.5% 12.5% / 0.2)", "rgba(223, 159, 159, 0.2)", +"hwb(0deg 62.5% 12.5% / 1)", "rgb(223, 159, 159)", +"hwb(0 62.5% 12.5% / 1)", "rgb(223, 159, 159)", +"hwb(0deg 62.5% 25%)", "rgb(191, 159, 159)", +"hwb(0 62.5% 25%)", "rgb(191, 159, 159)", +"hwb(0deg 62.5% 25% / 0)", "rgba(191, 159, 159, 0)", +"hwb(0 62.5% 25% / 0)", "rgba(191, 159, 159, 0)", +"hwb(0deg 62.5% 25% / 0.2)", "rgba(191, 159, 159, 0.2)", +"hwb(0 62.5% 25% / 0.2)", "rgba(191, 159, 159, 0.2)", +"hwb(0deg 62.5% 25% / 1)", "rgb(191, 159, 159)", +"hwb(0 62.5% 25% / 1)", "rgb(191, 159, 159)", +"hwb(0deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(0 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(0deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(0 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(0deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(0 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(0deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(0 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(0deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(0 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(0deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(0 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(0deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(0 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(0deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(0 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(0deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(0 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(0deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(0 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(0deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(0 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(0deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(0 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(0deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(0 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(0deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(0 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(0deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(0 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(0deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(0 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(0deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(0 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(0deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(0 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(0deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(0 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(0deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(0 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(0deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(0 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(0deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(0 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(0deg 75% 0%)", "rgb(255, 191, 191)", +"hwb(0 75% 0%)", "rgb(255, 191, 191)", +"hwb(0deg 75% 0% / 0)", "rgba(255, 191, 191, 0)", +"hwb(0 75% 0% / 0)", "rgba(255, 191, 191, 0)", +"hwb(0deg 75% 0% / 0.2)", "rgba(255, 191, 191, 0.2)", +"hwb(0 75% 0% / 0.2)", "rgba(255, 191, 191, 0.2)", +"hwb(0deg 75% 0% / 1)", "rgb(255, 191, 191)", +"hwb(0 75% 0% / 1)", "rgb(255, 191, 191)", +"hwb(0deg 75% 12.5%)", "rgb(223, 191, 191)", +"hwb(0 75% 12.5%)", "rgb(223, 191, 191)", +"hwb(0deg 75% 12.5% / 0)", "rgba(223, 191, 191, 0)", +"hwb(0 75% 12.5% / 0)", "rgba(223, 191, 191, 0)", +"hwb(0deg 75% 12.5% / 0.2)", "rgba(223, 191, 191, 0.2)", +"hwb(0 75% 12.5% / 0.2)", "rgba(223, 191, 191, 0.2)", +"hwb(0deg 75% 12.5% / 1)", "rgb(223, 191, 191)", +"hwb(0 75% 12.5% / 1)", "rgb(223, 191, 191)", +"hwb(0deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(0 75% 25%)", "rgb(191, 191, 191)", +"hwb(0deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(0 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(0deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(0 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(0deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(0 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(0deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(0 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(0deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(0 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(0deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(0 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(0deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(0 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(0deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(0 75% 50%)", "rgb(153, 153, 153)", +"hwb(0deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(0 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(0deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(0 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(0deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(0 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(0deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(0 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(0deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(0 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(0deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(0 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(0deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(0 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(0deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(0 75% 75%)", "rgb(128, 128, 128)", +"hwb(0deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(0 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(0deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(0 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(0deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(0 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(0deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(0 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(0deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(0 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(0deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(0 75% 100%)", "rgb(109, 109, 109)", +"hwb(0deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(0 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(0deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(0 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(0deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(0 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(0deg 87.5% 0%)", "rgb(255, 223, 223)", +"hwb(0 87.5% 0%)", "rgb(255, 223, 223)", +"hwb(0deg 87.5% 0% / 0)", "rgba(255, 223, 223, 0)", +"hwb(0 87.5% 0% / 0)", "rgba(255, 223, 223, 0)", +"hwb(0deg 87.5% 0% / 0.2)", "rgba(255, 223, 223, 0.2)", +"hwb(0 87.5% 0% / 0.2)", "rgba(255, 223, 223, 0.2)", +"hwb(0deg 87.5% 0% / 1)", "rgb(255, 223, 223)", +"hwb(0 87.5% 0% / 1)", "rgb(255, 223, 223)", +"hwb(0deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(0 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(0deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(0 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(0deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(0 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(0deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(0 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(0deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(0 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(0deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(0 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(0deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(0 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(0deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(0 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(0deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(0 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(0deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(0 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(0deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(0 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(0deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(0 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(0deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(0 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(0deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(0 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(0deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(0 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(0deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(0 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(0deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(0 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(0deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(0 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(0deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(0 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(0deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(0 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(0deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(0 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(0deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(0 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(0deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(0 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(0deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(0 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(0deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(0 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(0deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(0 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(0deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(0 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(0deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(0 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(0deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(0 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(0deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(0 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(0deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(0 100% 0%)", "rgb(255, 255, 255)", +"hwb(0deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(0 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(0deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(0 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(0deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(0 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(0deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(0 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(0deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(0 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(0deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(0 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(0deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(0 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(0deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(0 100% 25%)", "rgb(204, 204, 204)", +"hwb(0deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(0 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(0deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(0 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(0deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(0 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(0deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(0 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(0deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(0 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(0deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(0 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(0deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(0 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(0deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(0 100% 50%)", "rgb(170, 170, 170)", +"hwb(0deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(0 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(0deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(0 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(0deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(0 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(0deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(0 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(0deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(0 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(0deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(0 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(0deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(0 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(0deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(0 100% 75%)", "rgb(146, 146, 146)", +"hwb(0deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(0 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(0deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(0 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(0deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(0 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(0deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(0 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(0deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(0 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(0deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(0 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(0deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(0 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(0deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(0 100% 100%)", "rgb(128, 128, 128)", +"hwb(0deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(0deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(0deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(0 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(30deg 0% 0%)", "rgb(255, 128, 0)", +"hwb(30 0% 0%)", "rgb(255, 128, 0)", +"hwb(30deg 0% 0% / 0)", "rgba(255, 128, 0, 0)", +"hwb(30 0% 0% / 0)", "rgba(255, 128, 0, 0)", +"hwb(30deg 0% 0% / 0.2)", "rgba(255, 128, 0, 0.2)", +"hwb(30 0% 0% / 0.2)", "rgba(255, 128, 0, 0.2)", +"hwb(30deg 0% 0% / 1)", "rgb(255, 128, 0)", +"hwb(30 0% 0% / 1)", "rgb(255, 128, 0)", +"hwb(30deg 0% 12.5%)", "rgb(223, 112, 0)", +"hwb(30 0% 12.5%)", "rgb(223, 112, 0)", +"hwb(30deg 0% 12.5% / 0)", "rgba(223, 112, 0, 0)", +"hwb(30 0% 12.5% / 0)", "rgba(223, 112, 0, 0)", +"hwb(30deg 0% 12.5% / 0.2)", "rgba(223, 112, 0, 0.2)", +"hwb(30 0% 12.5% / 0.2)", "rgba(223, 112, 0, 0.2)", +"hwb(30deg 0% 12.5% / 1)", "rgb(223, 112, 0)", +"hwb(30 0% 12.5% / 1)", "rgb(223, 112, 0)", +"hwb(30deg 0% 25%)", "rgb(191, 96, 0)", +"hwb(30 0% 25%)", "rgb(191, 96, 0)", +"hwb(30deg 0% 25% / 0)", "rgba(191, 96, 0, 0)", +"hwb(30 0% 25% / 0)", "rgba(191, 96, 0, 0)", +"hwb(30deg 0% 25% / 0.2)", "rgba(191, 96, 0, 0.2)", +"hwb(30 0% 25% / 0.2)", "rgba(191, 96, 0, 0.2)", +"hwb(30deg 0% 25% / 1)", "rgb(191, 96, 0)", +"hwb(30 0% 25% / 1)", "rgb(191, 96, 0)", +"hwb(30deg 0% 37.5%)", "rgb(159, 80, 0)", +"hwb(30 0% 37.5%)", "rgb(159, 80, 0)", +"hwb(30deg 0% 37.5% / 0)", "rgba(159, 80, 0, 0)", +"hwb(30 0% 37.5% / 0)", "rgba(159, 80, 0, 0)", +"hwb(30deg 0% 37.5% / 0.2)", "rgba(159, 80, 0, 0.2)", +"hwb(30 0% 37.5% / 0.2)", "rgba(159, 80, 0, 0.2)", +"hwb(30deg 0% 37.5% / 1)", "rgb(159, 80, 0)", +"hwb(30 0% 37.5% / 1)", "rgb(159, 80, 0)", +"hwb(30deg 0% 50%)", "rgb(128, 64, 0)", +"hwb(30 0% 50%)", "rgb(128, 64, 0)", +"hwb(30deg 0% 50% / 0)", "rgba(128, 64, 0, 0)", +"hwb(30 0% 50% / 0)", "rgba(128, 64, 0, 0)", +"hwb(30deg 0% 50% / 0.2)", "rgba(128, 64, 0, 0.2)", +"hwb(30 0% 50% / 0.2)", "rgba(128, 64, 0, 0.2)", +"hwb(30deg 0% 50% / 1)", "rgb(128, 64, 0)", +"hwb(30 0% 50% / 1)", "rgb(128, 64, 0)", +"hwb(30deg 0% 62.5%)", "rgb(96, 48, 0)", +"hwb(30 0% 62.5%)", "rgb(96, 48, 0)", +"hwb(30deg 0% 62.5% / 0)", "rgba(96, 48, 0, 0)", +"hwb(30 0% 62.5% / 0)", "rgba(96, 48, 0, 0)", +"hwb(30deg 0% 62.5% / 0.2)", "rgba(96, 48, 0, 0.2)", +"hwb(30 0% 62.5% / 0.2)", "rgba(96, 48, 0, 0.2)", +"hwb(30deg 0% 62.5% / 1)", "rgb(96, 48, 0)", +"hwb(30 0% 62.5% / 1)", "rgb(96, 48, 0)", +"hwb(30deg 0% 75%)", "rgb(64, 32, 0)", +"hwb(30 0% 75%)", "rgb(64, 32, 0)", +"hwb(30deg 0% 75% / 0)", "rgba(64, 32, 0, 0)", +"hwb(30 0% 75% / 0)", "rgba(64, 32, 0, 0)", +"hwb(30deg 0% 75% / 0.2)", "rgba(64, 32, 0, 0.2)", +"hwb(30 0% 75% / 0.2)", "rgba(64, 32, 0, 0.2)", +"hwb(30deg 0% 75% / 1)", "rgb(64, 32, 0)", +"hwb(30 0% 75% / 1)", "rgb(64, 32, 0)", +"hwb(30deg 0% 87.5%)", "rgb(32, 16, 0)", +"hwb(30 0% 87.5%)", "rgb(32, 16, 0)", +"hwb(30deg 0% 87.5% / 0)", "rgba(32, 16, 0, 0)", +"hwb(30 0% 87.5% / 0)", "rgba(32, 16, 0, 0)", +"hwb(30deg 0% 87.5% / 0.2)", "rgba(32, 16, 0, 0.2)", +"hwb(30 0% 87.5% / 0.2)", "rgba(32, 16, 0, 0.2)", +"hwb(30deg 0% 87.5% / 1)", "rgb(32, 16, 0)", +"hwb(30 0% 87.5% / 1)", "rgb(32, 16, 0)", +"hwb(30deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(30 0% 100%)", "rgb(0, 0, 0)", +"hwb(30deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(30 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(30deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(30 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(30deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(30 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(30deg 12.5% 0%)", "rgb(255, 143, 32)", +"hwb(30 12.5% 0%)", "rgb(255, 143, 32)", +"hwb(30deg 12.5% 0% / 0)", "rgba(255, 143, 32, 0)", +"hwb(30 12.5% 0% / 0)", "rgba(255, 143, 32, 0)", +"hwb(30deg 12.5% 0% / 0.2)", "rgba(255, 143, 32, 0.2)", +"hwb(30 12.5% 0% / 0.2)", "rgba(255, 143, 32, 0.2)", +"hwb(30deg 12.5% 0% / 1)", "rgb(255, 143, 32)", +"hwb(30 12.5% 0% / 1)", "rgb(255, 143, 32)", +"hwb(30deg 12.5% 12.5%)", "rgb(223, 128, 32)", +"hwb(30 12.5% 12.5%)", "rgb(223, 128, 32)", +"hwb(30deg 12.5% 12.5% / 0)", "rgba(223, 128, 32, 0)", +"hwb(30 12.5% 12.5% / 0)", "rgba(223, 128, 32, 0)", +"hwb(30deg 12.5% 12.5% / 0.2)", "rgba(223, 128, 32, 0.2)", +"hwb(30 12.5% 12.5% / 0.2)", "rgba(223, 128, 32, 0.2)", +"hwb(30deg 12.5% 12.5% / 1)", "rgb(223, 128, 32)", +"hwb(30 12.5% 12.5% / 1)", "rgb(223, 128, 32)", +"hwb(30deg 12.5% 25%)", "rgb(191, 112, 32)", +"hwb(30 12.5% 25%)", "rgb(191, 112, 32)", +"hwb(30deg 12.5% 25% / 0)", "rgba(191, 112, 32, 0)", +"hwb(30 12.5% 25% / 0)", "rgba(191, 112, 32, 0)", +"hwb(30deg 12.5% 25% / 0.2)", "rgba(191, 112, 32, 0.2)", +"hwb(30 12.5% 25% / 0.2)", "rgba(191, 112, 32, 0.2)", +"hwb(30deg 12.5% 25% / 1)", "rgb(191, 112, 32)", +"hwb(30 12.5% 25% / 1)", "rgb(191, 112, 32)", +"hwb(30deg 12.5% 37.5%)", "rgb(159, 96, 32)", +"hwb(30 12.5% 37.5%)", "rgb(159, 96, 32)", +"hwb(30deg 12.5% 37.5% / 0)", "rgba(159, 96, 32, 0)", +"hwb(30 12.5% 37.5% / 0)", "rgba(159, 96, 32, 0)", +"hwb(30deg 12.5% 37.5% / 0.2)", "rgba(159, 96, 32, 0.2)", +"hwb(30 12.5% 37.5% / 0.2)", "rgba(159, 96, 32, 0.2)", +"hwb(30deg 12.5% 37.5% / 1)", "rgb(159, 96, 32)", +"hwb(30 12.5% 37.5% / 1)", "rgb(159, 96, 32)", +"hwb(30deg 12.5% 50%)", "rgb(128, 80, 32)", +"hwb(30 12.5% 50%)", "rgb(128, 80, 32)", +"hwb(30deg 12.5% 50% / 0)", "rgba(128, 80, 32, 0)", +"hwb(30 12.5% 50% / 0)", "rgba(128, 80, 32, 0)", +"hwb(30deg 12.5% 50% / 0.2)", "rgba(128, 80, 32, 0.2)", +"hwb(30 12.5% 50% / 0.2)", "rgba(128, 80, 32, 0.2)", +"hwb(30deg 12.5% 50% / 1)", "rgb(128, 80, 32)", +"hwb(30 12.5% 50% / 1)", "rgb(128, 80, 32)", +"hwb(30deg 12.5% 62.5%)", "rgb(96, 64, 32)", +"hwb(30 12.5% 62.5%)", "rgb(96, 64, 32)", +"hwb(30deg 12.5% 62.5% / 0)", "rgba(96, 64, 32, 0)", +"hwb(30 12.5% 62.5% / 0)", "rgba(96, 64, 32, 0)", +"hwb(30deg 12.5% 62.5% / 0.2)", "rgba(96, 64, 32, 0.2)", +"hwb(30 12.5% 62.5% / 0.2)", "rgba(96, 64, 32, 0.2)", +"hwb(30deg 12.5% 62.5% / 1)", "rgb(96, 64, 32)", +"hwb(30 12.5% 62.5% / 1)", "rgb(96, 64, 32)", +"hwb(30deg 12.5% 75%)", "rgb(64, 48, 32)", +"hwb(30 12.5% 75%)", "rgb(64, 48, 32)", +"hwb(30deg 12.5% 75% / 0)", "rgba(64, 48, 32, 0)", +"hwb(30 12.5% 75% / 0)", "rgba(64, 48, 32, 0)", +"hwb(30deg 12.5% 75% / 0.2)", "rgba(64, 48, 32, 0.2)", +"hwb(30 12.5% 75% / 0.2)", "rgba(64, 48, 32, 0.2)", +"hwb(30deg 12.5% 75% / 1)", "rgb(64, 48, 32)", +"hwb(30 12.5% 75% / 1)", "rgb(64, 48, 32)", +"hwb(30deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(30 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(30deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(30 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(30deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(30 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(30deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(30 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(30deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(30 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(30deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(30 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(30deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(30 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(30deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(30 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(30deg 25% 0%)", "rgb(255, 159, 64)", +"hwb(30 25% 0%)", "rgb(255, 159, 64)", +"hwb(30deg 25% 0% / 0)", "rgba(255, 159, 64, 0)", +"hwb(30 25% 0% / 0)", "rgba(255, 159, 64, 0)", +"hwb(30deg 25% 0% / 0.2)", "rgba(255, 159, 64, 0.2)", +"hwb(30 25% 0% / 0.2)", "rgba(255, 159, 64, 0.2)", +"hwb(30deg 25% 0% / 1)", "rgb(255, 159, 64)", +"hwb(30 25% 0% / 1)", "rgb(255, 159, 64)", +"hwb(30deg 25% 12.5%)", "rgb(223, 143, 64)", +"hwb(30 25% 12.5%)", "rgb(223, 143, 64)", +"hwb(30deg 25% 12.5% / 0)", "rgba(223, 143, 64, 0)", +"hwb(30 25% 12.5% / 0)", "rgba(223, 143, 64, 0)", +"hwb(30deg 25% 12.5% / 0.2)", "rgba(223, 143, 64, 0.2)", +"hwb(30 25% 12.5% / 0.2)", "rgba(223, 143, 64, 0.2)", +"hwb(30deg 25% 12.5% / 1)", "rgb(223, 143, 64)", +"hwb(30 25% 12.5% / 1)", "rgb(223, 143, 64)", +"hwb(30deg 25% 25%)", "rgb(191, 128, 64)", +"hwb(30 25% 25%)", "rgb(191, 128, 64)", +"hwb(30deg 25% 25% / 0)", "rgba(191, 128, 64, 0)", +"hwb(30 25% 25% / 0)", "rgba(191, 128, 64, 0)", +"hwb(30deg 25% 25% / 0.2)", "rgba(191, 128, 64, 0.2)", +"hwb(30 25% 25% / 0.2)", "rgba(191, 128, 64, 0.2)", +"hwb(30deg 25% 25% / 1)", "rgb(191, 128, 64)", +"hwb(30 25% 25% / 1)", "rgb(191, 128, 64)", +"hwb(30deg 25% 37.5%)", "rgb(159, 112, 64)", +"hwb(30 25% 37.5%)", "rgb(159, 112, 64)", +"hwb(30deg 25% 37.5% / 0)", "rgba(159, 112, 64, 0)", +"hwb(30 25% 37.5% / 0)", "rgba(159, 112, 64, 0)", +"hwb(30deg 25% 37.5% / 0.2)", "rgba(159, 112, 64, 0.2)", +"hwb(30 25% 37.5% / 0.2)", "rgba(159, 112, 64, 0.2)", +"hwb(30deg 25% 37.5% / 1)", "rgb(159, 112, 64)", +"hwb(30 25% 37.5% / 1)", "rgb(159, 112, 64)", +"hwb(30deg 25% 50%)", "rgb(128, 96, 64)", +"hwb(30 25% 50%)", "rgb(128, 96, 64)", +"hwb(30deg 25% 50% / 0)", "rgba(128, 96, 64, 0)", +"hwb(30 25% 50% / 0)", "rgba(128, 96, 64, 0)", +"hwb(30deg 25% 50% / 0.2)", "rgba(128, 96, 64, 0.2)", +"hwb(30 25% 50% / 0.2)", "rgba(128, 96, 64, 0.2)", +"hwb(30deg 25% 50% / 1)", "rgb(128, 96, 64)", +"hwb(30 25% 50% / 1)", "rgb(128, 96, 64)", +"hwb(30deg 25% 62.5%)", "rgb(96, 80, 64)", +"hwb(30 25% 62.5%)", "rgb(96, 80, 64)", +"hwb(30deg 25% 62.5% / 0)", "rgba(96, 80, 64, 0)", +"hwb(30 25% 62.5% / 0)", "rgba(96, 80, 64, 0)", +"hwb(30deg 25% 62.5% / 0.2)", "rgba(96, 80, 64, 0.2)", +"hwb(30 25% 62.5% / 0.2)", "rgba(96, 80, 64, 0.2)", +"hwb(30deg 25% 62.5% / 1)", "rgb(96, 80, 64)", +"hwb(30 25% 62.5% / 1)", "rgb(96, 80, 64)", +"hwb(30deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(30 25% 75%)", "rgb(64, 64, 64)", +"hwb(30deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(30 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(30deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(30 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(30deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(30 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(30deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(30 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(30deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(30 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(30deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(30 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(30deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(30 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(30deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(30 25% 100%)", "rgb(51, 51, 51)", +"hwb(30deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(30 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(30deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(30 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(30deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(30 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(30deg 37.5% 0%)", "rgb(255, 175, 96)", +"hwb(30 37.5% 0%)", "rgb(255, 175, 96)", +"hwb(30deg 37.5% 0% / 0)", "rgba(255, 175, 96, 0)", +"hwb(30 37.5% 0% / 0)", "rgba(255, 175, 96, 0)", +"hwb(30deg 37.5% 0% / 0.2)", "rgba(255, 175, 96, 0.2)", +"hwb(30 37.5% 0% / 0.2)", "rgba(255, 175, 96, 0.2)", +"hwb(30deg 37.5% 0% / 1)", "rgb(255, 175, 96)", +"hwb(30 37.5% 0% / 1)", "rgb(255, 175, 96)", +"hwb(30deg 37.5% 12.5%)", "rgb(223, 159, 96)", +"hwb(30 37.5% 12.5%)", "rgb(223, 159, 96)", +"hwb(30deg 37.5% 12.5% / 0)", "rgba(223, 159, 96, 0)", +"hwb(30 37.5% 12.5% / 0)", "rgba(223, 159, 96, 0)", +"hwb(30deg 37.5% 12.5% / 0.2)", "rgba(223, 159, 96, 0.2)", +"hwb(30 37.5% 12.5% / 0.2)", "rgba(223, 159, 96, 0.2)", +"hwb(30deg 37.5% 12.5% / 1)", "rgb(223, 159, 96)", +"hwb(30 37.5% 12.5% / 1)", "rgb(223, 159, 96)", +"hwb(30deg 37.5% 25%)", "rgb(191, 143, 96)", +"hwb(30 37.5% 25%)", "rgb(191, 143, 96)", +"hwb(30deg 37.5% 25% / 0)", "rgba(191, 143, 96, 0)", +"hwb(30 37.5% 25% / 0)", "rgba(191, 143, 96, 0)", +"hwb(30deg 37.5% 25% / 0.2)", "rgba(191, 143, 96, 0.2)", +"hwb(30 37.5% 25% / 0.2)", "rgba(191, 143, 96, 0.2)", +"hwb(30deg 37.5% 25% / 1)", "rgb(191, 143, 96)", +"hwb(30 37.5% 25% / 1)", "rgb(191, 143, 96)", +"hwb(30deg 37.5% 37.5%)", "rgb(159, 128, 96)", +"hwb(30 37.5% 37.5%)", "rgb(159, 128, 96)", +"hwb(30deg 37.5% 37.5% / 0)", "rgba(159, 128, 96, 0)", +"hwb(30 37.5% 37.5% / 0)", "rgba(159, 128, 96, 0)", +"hwb(30deg 37.5% 37.5% / 0.2)", "rgba(159, 128, 96, 0.2)", +"hwb(30 37.5% 37.5% / 0.2)", "rgba(159, 128, 96, 0.2)", +"hwb(30deg 37.5% 37.5% / 1)", "rgb(159, 128, 96)", +"hwb(30 37.5% 37.5% / 1)", "rgb(159, 128, 96)", +"hwb(30deg 37.5% 50%)", "rgb(128, 112, 96)", +"hwb(30 37.5% 50%)", "rgb(128, 112, 96)", +"hwb(30deg 37.5% 50% / 0)", "rgba(128, 112, 96, 0)", +"hwb(30 37.5% 50% / 0)", "rgba(128, 112, 96, 0)", +"hwb(30deg 37.5% 50% / 0.2)", "rgba(128, 112, 96, 0.2)", +"hwb(30 37.5% 50% / 0.2)", "rgba(128, 112, 96, 0.2)", +"hwb(30deg 37.5% 50% / 1)", "rgb(128, 112, 96)", +"hwb(30 37.5% 50% / 1)", "rgb(128, 112, 96)", +"hwb(30deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(30 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(30deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(30 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(30deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(30 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(30deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(30 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(30deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(30 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(30deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(30 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(30deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(30 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(30deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(30 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(30deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(30 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(30deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(30 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(30deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(30 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(30deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(30 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(30deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(30 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(30deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(30 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(30deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(30 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(30deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(30 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(30deg 50% 0%)", "rgb(255, 191, 128)", +"hwb(30 50% 0%)", "rgb(255, 191, 128)", +"hwb(30deg 50% 0% / 0)", "rgba(255, 191, 128, 0)", +"hwb(30 50% 0% / 0)", "rgba(255, 191, 128, 0)", +"hwb(30deg 50% 0% / 0.2)", "rgba(255, 191, 128, 0.2)", +"hwb(30 50% 0% / 0.2)", "rgba(255, 191, 128, 0.2)", +"hwb(30deg 50% 0% / 1)", "rgb(255, 191, 128)", +"hwb(30 50% 0% / 1)", "rgb(255, 191, 128)", +"hwb(30deg 50% 12.5%)", "rgb(223, 175, 128)", +"hwb(30 50% 12.5%)", "rgb(223, 175, 128)", +"hwb(30deg 50% 12.5% / 0)", "rgba(223, 175, 128, 0)", +"hwb(30 50% 12.5% / 0)", "rgba(223, 175, 128, 0)", +"hwb(30deg 50% 12.5% / 0.2)", "rgba(223, 175, 128, 0.2)", +"hwb(30 50% 12.5% / 0.2)", "rgba(223, 175, 128, 0.2)", +"hwb(30deg 50% 12.5% / 1)", "rgb(223, 175, 128)", +"hwb(30 50% 12.5% / 1)", "rgb(223, 175, 128)", +"hwb(30deg 50% 25%)", "rgb(191, 159, 128)", +"hwb(30 50% 25%)", "rgb(191, 159, 128)", +"hwb(30deg 50% 25% / 0)", "rgba(191, 159, 128, 0)", +"hwb(30 50% 25% / 0)", "rgba(191, 159, 128, 0)", +"hwb(30deg 50% 25% / 0.2)", "rgba(191, 159, 128, 0.2)", +"hwb(30 50% 25% / 0.2)", "rgba(191, 159, 128, 0.2)", +"hwb(30deg 50% 25% / 1)", "rgb(191, 159, 128)", +"hwb(30 50% 25% / 1)", "rgb(191, 159, 128)", +"hwb(30deg 50% 37.5%)", "rgb(159, 143, 128)", +"hwb(30 50% 37.5%)", "rgb(159, 143, 128)", +"hwb(30deg 50% 37.5% / 0)", "rgba(159, 143, 128, 0)", +"hwb(30 50% 37.5% / 0)", "rgba(159, 143, 128, 0)", +"hwb(30deg 50% 37.5% / 0.2)", "rgba(159, 143, 128, 0.2)", +"hwb(30 50% 37.5% / 0.2)", "rgba(159, 143, 128, 0.2)", +"hwb(30deg 50% 37.5% / 1)", "rgb(159, 143, 128)", +"hwb(30 50% 37.5% / 1)", "rgb(159, 143, 128)", +"hwb(30deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(30 50% 50%)", "rgb(128, 128, 128)", +"hwb(30deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(30 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(30deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(30 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(30deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(30 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(30deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(30 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(30deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(30 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(30deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(30 50% 75%)", "rgb(102, 102, 102)", +"hwb(30deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(30 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(30deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(30 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(30deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(30 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(30deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(30 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(30deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(30 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(30deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(30 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(30deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(30 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(30deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(30 50% 100%)", "rgb(85, 85, 85)", +"hwb(30deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(30 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(30deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(30 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(30deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(30 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(30deg 62.5% 0%)", "rgb(255, 207, 159)", +"hwb(30 62.5% 0%)", "rgb(255, 207, 159)", +"hwb(30deg 62.5% 0% / 0)", "rgba(255, 207, 159, 0)", +"hwb(30 62.5% 0% / 0)", "rgba(255, 207, 159, 0)", +"hwb(30deg 62.5% 0% / 0.2)", "rgba(255, 207, 159, 0.2)", +"hwb(30 62.5% 0% / 0.2)", "rgba(255, 207, 159, 0.2)", +"hwb(30deg 62.5% 0% / 1)", "rgb(255, 207, 159)", +"hwb(30 62.5% 0% / 1)", "rgb(255, 207, 159)", +"hwb(30deg 62.5% 12.5%)", "rgb(223, 191, 159)", +"hwb(30 62.5% 12.5%)", "rgb(223, 191, 159)", +"hwb(30deg 62.5% 12.5% / 0)", "rgba(223, 191, 159, 0)", +"hwb(30 62.5% 12.5% / 0)", "rgba(223, 191, 159, 0)", +"hwb(30deg 62.5% 12.5% / 0.2)", "rgba(223, 191, 159, 0.2)", +"hwb(30 62.5% 12.5% / 0.2)", "rgba(223, 191, 159, 0.2)", +"hwb(30deg 62.5% 12.5% / 1)", "rgb(223, 191, 159)", +"hwb(30 62.5% 12.5% / 1)", "rgb(223, 191, 159)", +"hwb(30deg 62.5% 25%)", "rgb(191, 175, 159)", +"hwb(30 62.5% 25%)", "rgb(191, 175, 159)", +"hwb(30deg 62.5% 25% / 0)", "rgba(191, 175, 159, 0)", +"hwb(30 62.5% 25% / 0)", "rgba(191, 175, 159, 0)", +"hwb(30deg 62.5% 25% / 0.2)", "rgba(191, 175, 159, 0.2)", +"hwb(30 62.5% 25% / 0.2)", "rgba(191, 175, 159, 0.2)", +"hwb(30deg 62.5% 25% / 1)", "rgb(191, 175, 159)", +"hwb(30 62.5% 25% / 1)", "rgb(191, 175, 159)", +"hwb(30deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(30 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(30deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(30 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(30deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(30 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(30deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(30 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(30deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(30 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(30deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(30 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(30deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(30 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(30deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(30 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(30deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(30 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(30deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(30 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(30deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(30 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(30deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(30 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(30deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(30 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(30deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(30 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(30deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(30 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(30deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(30 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(30deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(30 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(30deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(30 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(30deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(30 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(30deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(30 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(30deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(30 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(30deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(30 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(30deg 75% 0%)", "rgb(255, 223, 191)", +"hwb(30 75% 0%)", "rgb(255, 223, 191)", +"hwb(30deg 75% 0% / 0)", "rgba(255, 223, 191, 0)", +"hwb(30 75% 0% / 0)", "rgba(255, 223, 191, 0)", +"hwb(30deg 75% 0% / 0.2)", "rgba(255, 223, 191, 0.2)", +"hwb(30 75% 0% / 0.2)", "rgba(255, 223, 191, 0.2)", +"hwb(30deg 75% 0% / 1)", "rgb(255, 223, 191)", +"hwb(30 75% 0% / 1)", "rgb(255, 223, 191)", +"hwb(30deg 75% 12.5%)", "rgb(223, 207, 191)", +"hwb(30 75% 12.5%)", "rgb(223, 207, 191)", +"hwb(30deg 75% 12.5% / 0)", "rgba(223, 207, 191, 0)", +"hwb(30 75% 12.5% / 0)", "rgba(223, 207, 191, 0)", +"hwb(30deg 75% 12.5% / 0.2)", "rgba(223, 207, 191, 0.2)", +"hwb(30 75% 12.5% / 0.2)", "rgba(223, 207, 191, 0.2)", +"hwb(30deg 75% 12.5% / 1)", "rgb(223, 207, 191)", +"hwb(30 75% 12.5% / 1)", "rgb(223, 207, 191)", +"hwb(30deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(30 75% 25%)", "rgb(191, 191, 191)", +"hwb(30deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(30 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(30deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(30 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(30deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(30 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(30deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(30 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(30deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(30 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(30deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(30 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(30deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(30 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(30deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(30 75% 50%)", "rgb(153, 153, 153)", +"hwb(30deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(30 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(30deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(30 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(30deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(30 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(30deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(30 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(30deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(30 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(30deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(30 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(30deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(30 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(30deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(30 75% 75%)", "rgb(128, 128, 128)", +"hwb(30deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(30 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(30deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(30 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(30deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(30 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(30deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(30 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(30deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(30 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(30deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(30 75% 100%)", "rgb(109, 109, 109)", +"hwb(30deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(30 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(30deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(30 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(30deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(30 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(30deg 87.5% 0%)", "rgb(255, 239, 223)", +"hwb(30 87.5% 0%)", "rgb(255, 239, 223)", +"hwb(30deg 87.5% 0% / 0)", "rgba(255, 239, 223, 0)", +"hwb(30 87.5% 0% / 0)", "rgba(255, 239, 223, 0)", +"hwb(30deg 87.5% 0% / 0.2)", "rgba(255, 239, 223, 0.2)", +"hwb(30 87.5% 0% / 0.2)", "rgba(255, 239, 223, 0.2)", +"hwb(30deg 87.5% 0% / 1)", "rgb(255, 239, 223)", +"hwb(30 87.5% 0% / 1)", "rgb(255, 239, 223)", +"hwb(30deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(30 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(30deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(30 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(30deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(30 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(30deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(30 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(30deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(30 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(30deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(30 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(30deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(30 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(30deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(30 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(30deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(30 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(30deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(30 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(30deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(30 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(30deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(30 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(30deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(30 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(30deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(30 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(30deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(30 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(30deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(30 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(30deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(30 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(30deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(30 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(30deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(30 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(30deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(30 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(30deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(30 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(30deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(30 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(30deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(30 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(30deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(30 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(30deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(30 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(30deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(30 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(30deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(30 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(30deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(30 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(30deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(30 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(30deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(30 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(30deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(30 100% 0%)", "rgb(255, 255, 255)", +"hwb(30deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(30 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(30deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(30 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(30deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(30 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(30deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(30 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(30deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(30 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(30deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(30 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(30deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(30 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(30deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(30 100% 25%)", "rgb(204, 204, 204)", +"hwb(30deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(30 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(30deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(30 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(30deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(30 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(30deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(30 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(30deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(30 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(30deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(30 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(30deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(30 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(30deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(30 100% 50%)", "rgb(170, 170, 170)", +"hwb(30deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(30 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(30deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(30 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(30deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(30 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(30deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(30 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(30deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(30 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(30deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(30 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(30deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(30 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(30deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(30 100% 75%)", "rgb(146, 146, 146)", +"hwb(30deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(30 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(30deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(30 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(30deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(30 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(30deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(30 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(30deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(30 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(30deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(30 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(30deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(30 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(30deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(30 100% 100%)", "rgb(128, 128, 128)", +"hwb(30deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(30deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(30deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(30 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(60deg 0% 0%)", "rgb(255, 255, 0)", +"hwb(60 0% 0%)", "rgb(255, 255, 0)", +"hwb(60deg 0% 0% / 0)", "rgba(255, 255, 0, 0)", +"hwb(60 0% 0% / 0)", "rgba(255, 255, 0, 0)", +"hwb(60deg 0% 0% / 0.2)", "rgba(255, 255, 0, 0.2)", +"hwb(60 0% 0% / 0.2)", "rgba(255, 255, 0, 0.2)", +"hwb(60deg 0% 0% / 1)", "rgb(255, 255, 0)", +"hwb(60 0% 0% / 1)", "rgb(255, 255, 0)", +"hwb(60deg 0% 12.5%)", "rgb(223, 223, 0)", +"hwb(60 0% 12.5%)", "rgb(223, 223, 0)", +"hwb(60deg 0% 12.5% / 0)", "rgba(223, 223, 0, 0)", +"hwb(60 0% 12.5% / 0)", "rgba(223, 223, 0, 0)", +"hwb(60deg 0% 12.5% / 0.2)", "rgba(223, 223, 0, 0.2)", +"hwb(60 0% 12.5% / 0.2)", "rgba(223, 223, 0, 0.2)", +"hwb(60deg 0% 12.5% / 1)", "rgb(223, 223, 0)", +"hwb(60 0% 12.5% / 1)", "rgb(223, 223, 0)", +"hwb(60deg 0% 25%)", "rgb(191, 191, 0)", +"hwb(60 0% 25%)", "rgb(191, 191, 0)", +"hwb(60deg 0% 25% / 0)", "rgba(191, 191, 0, 0)", +"hwb(60 0% 25% / 0)", "rgba(191, 191, 0, 0)", +"hwb(60deg 0% 25% / 0.2)", "rgba(191, 191, 0, 0.2)", +"hwb(60 0% 25% / 0.2)", "rgba(191, 191, 0, 0.2)", +"hwb(60deg 0% 25% / 1)", "rgb(191, 191, 0)", +"hwb(60 0% 25% / 1)", "rgb(191, 191, 0)", +"hwb(60deg 0% 37.5%)", "rgb(159, 159, 0)", +"hwb(60 0% 37.5%)", "rgb(159, 159, 0)", +"hwb(60deg 0% 37.5% / 0)", "rgba(159, 159, 0, 0)", +"hwb(60 0% 37.5% / 0)", "rgba(159, 159, 0, 0)", +"hwb(60deg 0% 37.5% / 0.2)", "rgba(159, 159, 0, 0.2)", +"hwb(60 0% 37.5% / 0.2)", "rgba(159, 159, 0, 0.2)", +"hwb(60deg 0% 37.5% / 1)", "rgb(159, 159, 0)", +"hwb(60 0% 37.5% / 1)", "rgb(159, 159, 0)", +"hwb(60deg 0% 50%)", "rgb(128, 128, 0)", +"hwb(60 0% 50%)", "rgb(128, 128, 0)", +"hwb(60deg 0% 50% / 0)", "rgba(128, 128, 0, 0)", +"hwb(60 0% 50% / 0)", "rgba(128, 128, 0, 0)", +"hwb(60deg 0% 50% / 0.2)", "rgba(128, 128, 0, 0.2)", +"hwb(60 0% 50% / 0.2)", "rgba(128, 128, 0, 0.2)", +"hwb(60deg 0% 50% / 1)", "rgb(128, 128, 0)", +"hwb(60 0% 50% / 1)", "rgb(128, 128, 0)", +"hwb(60deg 0% 62.5%)", "rgb(96, 96, 0)", +"hwb(60 0% 62.5%)", "rgb(96, 96, 0)", +"hwb(60deg 0% 62.5% / 0)", "rgba(96, 96, 0, 0)", +"hwb(60 0% 62.5% / 0)", "rgba(96, 96, 0, 0)", +"hwb(60deg 0% 62.5% / 0.2)", "rgba(96, 96, 0, 0.2)", +"hwb(60 0% 62.5% / 0.2)", "rgba(96, 96, 0, 0.2)", +"hwb(60deg 0% 62.5% / 1)", "rgb(96, 96, 0)", +"hwb(60 0% 62.5% / 1)", "rgb(96, 96, 0)", +"hwb(60deg 0% 75%)", "rgb(64, 64, 0)", +"hwb(60 0% 75%)", "rgb(64, 64, 0)", +"hwb(60deg 0% 75% / 0)", "rgba(64, 64, 0, 0)", +"hwb(60 0% 75% / 0)", "rgba(64, 64, 0, 0)", +"hwb(60deg 0% 75% / 0.2)", "rgba(64, 64, 0, 0.2)", +"hwb(60 0% 75% / 0.2)", "rgba(64, 64, 0, 0.2)", +"hwb(60deg 0% 75% / 1)", "rgb(64, 64, 0)", +"hwb(60 0% 75% / 1)", "rgb(64, 64, 0)", +"hwb(60deg 0% 87.5%)", "rgb(32, 32, 0)", +"hwb(60 0% 87.5%)", "rgb(32, 32, 0)", +"hwb(60deg 0% 87.5% / 0)", "rgba(32, 32, 0, 0)", +"hwb(60 0% 87.5% / 0)", "rgba(32, 32, 0, 0)", +"hwb(60deg 0% 87.5% / 0.2)", "rgba(32, 32, 0, 0.2)", +"hwb(60 0% 87.5% / 0.2)", "rgba(32, 32, 0, 0.2)", +"hwb(60deg 0% 87.5% / 1)", "rgb(32, 32, 0)", +"hwb(60 0% 87.5% / 1)", "rgb(32, 32, 0)", +"hwb(60deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(60 0% 100%)", "rgb(0, 0, 0)", +"hwb(60deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(60 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(60deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(60 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(60deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(60 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(60deg 12.5% 0%)", "rgb(255, 255, 32)", +"hwb(60 12.5% 0%)", "rgb(255, 255, 32)", +"hwb(60deg 12.5% 0% / 0)", "rgba(255, 255, 32, 0)", +"hwb(60 12.5% 0% / 0)", "rgba(255, 255, 32, 0)", +"hwb(60deg 12.5% 0% / 0.2)", "rgba(255, 255, 32, 0.2)", +"hwb(60 12.5% 0% / 0.2)", "rgba(255, 255, 32, 0.2)", +"hwb(60deg 12.5% 0% / 1)", "rgb(255, 255, 32)", +"hwb(60 12.5% 0% / 1)", "rgb(255, 255, 32)", +"hwb(60deg 12.5% 12.5%)", "rgb(223, 223, 32)", +"hwb(60 12.5% 12.5%)", "rgb(223, 223, 32)", +"hwb(60deg 12.5% 12.5% / 0)", "rgba(223, 223, 32, 0)", +"hwb(60 12.5% 12.5% / 0)", "rgba(223, 223, 32, 0)", +"hwb(60deg 12.5% 12.5% / 0.2)", "rgba(223, 223, 32, 0.2)", +"hwb(60 12.5% 12.5% / 0.2)", "rgba(223, 223, 32, 0.2)", +"hwb(60deg 12.5% 12.5% / 1)", "rgb(223, 223, 32)", +"hwb(60 12.5% 12.5% / 1)", "rgb(223, 223, 32)", +"hwb(60deg 12.5% 25%)", "rgb(191, 191, 32)", +"hwb(60 12.5% 25%)", "rgb(191, 191, 32)", +"hwb(60deg 12.5% 25% / 0)", "rgba(191, 191, 32, 0)", +"hwb(60 12.5% 25% / 0)", "rgba(191, 191, 32, 0)", +"hwb(60deg 12.5% 25% / 0.2)", "rgba(191, 191, 32, 0.2)", +"hwb(60 12.5% 25% / 0.2)", "rgba(191, 191, 32, 0.2)", +"hwb(60deg 12.5% 25% / 1)", "rgb(191, 191, 32)", +"hwb(60 12.5% 25% / 1)", "rgb(191, 191, 32)", +"hwb(60deg 12.5% 37.5%)", "rgb(159, 159, 32)", +"hwb(60 12.5% 37.5%)", "rgb(159, 159, 32)", +"hwb(60deg 12.5% 37.5% / 0)", "rgba(159, 159, 32, 0)", +"hwb(60 12.5% 37.5% / 0)", "rgba(159, 159, 32, 0)", +"hwb(60deg 12.5% 37.5% / 0.2)", "rgba(159, 159, 32, 0.2)", +"hwb(60 12.5% 37.5% / 0.2)", "rgba(159, 159, 32, 0.2)", +"hwb(60deg 12.5% 37.5% / 1)", "rgb(159, 159, 32)", +"hwb(60 12.5% 37.5% / 1)", "rgb(159, 159, 32)", +"hwb(60deg 12.5% 50%)", "rgb(128, 128, 32)", +"hwb(60 12.5% 50%)", "rgb(128, 128, 32)", +"hwb(60deg 12.5% 50% / 0)", "rgba(128, 128, 32, 0)", +"hwb(60 12.5% 50% / 0)", "rgba(128, 128, 32, 0)", +"hwb(60deg 12.5% 50% / 0.2)", "rgba(128, 128, 32, 0.2)", +"hwb(60 12.5% 50% / 0.2)", "rgba(128, 128, 32, 0.2)", +"hwb(60deg 12.5% 50% / 1)", "rgb(128, 128, 32)", +"hwb(60 12.5% 50% / 1)", "rgb(128, 128, 32)", +"hwb(60deg 12.5% 62.5%)", "rgb(96, 96, 32)", +"hwb(60 12.5% 62.5%)", "rgb(96, 96, 32)", +"hwb(60deg 12.5% 62.5% / 0)", "rgba(96, 96, 32, 0)", +"hwb(60 12.5% 62.5% / 0)", "rgba(96, 96, 32, 0)", +"hwb(60deg 12.5% 62.5% / 0.2)", "rgba(96, 96, 32, 0.2)", +"hwb(60 12.5% 62.5% / 0.2)", "rgba(96, 96, 32, 0.2)", +"hwb(60deg 12.5% 62.5% / 1)", "rgb(96, 96, 32)", +"hwb(60 12.5% 62.5% / 1)", "rgb(96, 96, 32)", +"hwb(60deg 12.5% 75%)", "rgb(64, 64, 32)", +"hwb(60 12.5% 75%)", "rgb(64, 64, 32)", +"hwb(60deg 12.5% 75% / 0)", "rgba(64, 64, 32, 0)", +"hwb(60 12.5% 75% / 0)", "rgba(64, 64, 32, 0)", +"hwb(60deg 12.5% 75% / 0.2)", "rgba(64, 64, 32, 0.2)", +"hwb(60 12.5% 75% / 0.2)", "rgba(64, 64, 32, 0.2)", +"hwb(60deg 12.5% 75% / 1)", "rgb(64, 64, 32)", +"hwb(60 12.5% 75% / 1)", "rgb(64, 64, 32)", +"hwb(60deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(60 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(60deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(60 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(60deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(60 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(60deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(60 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(60deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(60 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(60deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(60 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(60deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(60 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(60deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(60 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(60deg 25% 0%)", "rgb(255, 255, 64)", +"hwb(60 25% 0%)", "rgb(255, 255, 64)", +"hwb(60deg 25% 0% / 0)", "rgba(255, 255, 64, 0)", +"hwb(60 25% 0% / 0)", "rgba(255, 255, 64, 0)", +"hwb(60deg 25% 0% / 0.2)", "rgba(255, 255, 64, 0.2)", +"hwb(60 25% 0% / 0.2)", "rgba(255, 255, 64, 0.2)", +"hwb(60deg 25% 0% / 1)", "rgb(255, 255, 64)", +"hwb(60 25% 0% / 1)", "rgb(255, 255, 64)", +"hwb(60deg 25% 12.5%)", "rgb(223, 223, 64)", +"hwb(60 25% 12.5%)", "rgb(223, 223, 64)", +"hwb(60deg 25% 12.5% / 0)", "rgba(223, 223, 64, 0)", +"hwb(60 25% 12.5% / 0)", "rgba(223, 223, 64, 0)", +"hwb(60deg 25% 12.5% / 0.2)", "rgba(223, 223, 64, 0.2)", +"hwb(60 25% 12.5% / 0.2)", "rgba(223, 223, 64, 0.2)", +"hwb(60deg 25% 12.5% / 1)", "rgb(223, 223, 64)", +"hwb(60 25% 12.5% / 1)", "rgb(223, 223, 64)", +"hwb(60deg 25% 25%)", "rgb(191, 191, 64)", +"hwb(60 25% 25%)", "rgb(191, 191, 64)", +"hwb(60deg 25% 25% / 0)", "rgba(191, 191, 64, 0)", +"hwb(60 25% 25% / 0)", "rgba(191, 191, 64, 0)", +"hwb(60deg 25% 25% / 0.2)", "rgba(191, 191, 64, 0.2)", +"hwb(60 25% 25% / 0.2)", "rgba(191, 191, 64, 0.2)", +"hwb(60deg 25% 25% / 1)", "rgb(191, 191, 64)", +"hwb(60 25% 25% / 1)", "rgb(191, 191, 64)", +"hwb(60deg 25% 37.5%)", "rgb(159, 159, 64)", +"hwb(60 25% 37.5%)", "rgb(159, 159, 64)", +"hwb(60deg 25% 37.5% / 0)", "rgba(159, 159, 64, 0)", +"hwb(60 25% 37.5% / 0)", "rgba(159, 159, 64, 0)", +"hwb(60deg 25% 37.5% / 0.2)", "rgba(159, 159, 64, 0.2)", +"hwb(60 25% 37.5% / 0.2)", "rgba(159, 159, 64, 0.2)", +"hwb(60deg 25% 37.5% / 1)", "rgb(159, 159, 64)", +"hwb(60 25% 37.5% / 1)", "rgb(159, 159, 64)", +"hwb(60deg 25% 50%)", "rgb(128, 128, 64)", +"hwb(60 25% 50%)", "rgb(128, 128, 64)", +"hwb(60deg 25% 50% / 0)", "rgba(128, 128, 64, 0)", +"hwb(60 25% 50% / 0)", "rgba(128, 128, 64, 0)", +"hwb(60deg 25% 50% / 0.2)", "rgba(128, 128, 64, 0.2)", +"hwb(60 25% 50% / 0.2)", "rgba(128, 128, 64, 0.2)", +"hwb(60deg 25% 50% / 1)", "rgb(128, 128, 64)", +"hwb(60 25% 50% / 1)", "rgb(128, 128, 64)", +"hwb(60deg 25% 62.5%)", "rgb(96, 96, 64)", +"hwb(60 25% 62.5%)", "rgb(96, 96, 64)", +"hwb(60deg 25% 62.5% / 0)", "rgba(96, 96, 64, 0)", +"hwb(60 25% 62.5% / 0)", "rgba(96, 96, 64, 0)", +"hwb(60deg 25% 62.5% / 0.2)", "rgba(96, 96, 64, 0.2)", +"hwb(60 25% 62.5% / 0.2)", "rgba(96, 96, 64, 0.2)", +"hwb(60deg 25% 62.5% / 1)", "rgb(96, 96, 64)", +"hwb(60 25% 62.5% / 1)", "rgb(96, 96, 64)", +"hwb(60deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(60 25% 75%)", "rgb(64, 64, 64)", +"hwb(60deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(60 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(60deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(60 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(60deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(60 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(60deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(60 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(60deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(60 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(60deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(60 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(60deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(60 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(60deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(60 25% 100%)", "rgb(51, 51, 51)", +"hwb(60deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(60 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(60deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(60 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(60deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(60 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(60deg 37.5% 0%)", "rgb(255, 255, 96)", +"hwb(60 37.5% 0%)", "rgb(255, 255, 96)", +"hwb(60deg 37.5% 0% / 0)", "rgba(255, 255, 96, 0)", +"hwb(60 37.5% 0% / 0)", "rgba(255, 255, 96, 0)", +"hwb(60deg 37.5% 0% / 0.2)", "rgba(255, 255, 96, 0.2)", +"hwb(60 37.5% 0% / 0.2)", "rgba(255, 255, 96, 0.2)", +"hwb(60deg 37.5% 0% / 1)", "rgb(255, 255, 96)", +"hwb(60 37.5% 0% / 1)", "rgb(255, 255, 96)", +"hwb(60deg 37.5% 12.5%)", "rgb(223, 223, 96)", +"hwb(60 37.5% 12.5%)", "rgb(223, 223, 96)", +"hwb(60deg 37.5% 12.5% / 0)", "rgba(223, 223, 96, 0)", +"hwb(60 37.5% 12.5% / 0)", "rgba(223, 223, 96, 0)", +"hwb(60deg 37.5% 12.5% / 0.2)", "rgba(223, 223, 96, 0.2)", +"hwb(60 37.5% 12.5% / 0.2)", "rgba(223, 223, 96, 0.2)", +"hwb(60deg 37.5% 12.5% / 1)", "rgb(223, 223, 96)", +"hwb(60 37.5% 12.5% / 1)", "rgb(223, 223, 96)", +"hwb(60deg 37.5% 25%)", "rgb(191, 191, 96)", +"hwb(60 37.5% 25%)", "rgb(191, 191, 96)", +"hwb(60deg 37.5% 25% / 0)", "rgba(191, 191, 96, 0)", +"hwb(60 37.5% 25% / 0)", "rgba(191, 191, 96, 0)", +"hwb(60deg 37.5% 25% / 0.2)", "rgba(191, 191, 96, 0.2)", +"hwb(60 37.5% 25% / 0.2)", "rgba(191, 191, 96, 0.2)", +"hwb(60deg 37.5% 25% / 1)", "rgb(191, 191, 96)", +"hwb(60 37.5% 25% / 1)", "rgb(191, 191, 96)", +"hwb(60deg 37.5% 37.5%)", "rgb(159, 159, 96)", +"hwb(60 37.5% 37.5%)", "rgb(159, 159, 96)", +"hwb(60deg 37.5% 37.5% / 0)", "rgba(159, 159, 96, 0)", +"hwb(60 37.5% 37.5% / 0)", "rgba(159, 159, 96, 0)", +"hwb(60deg 37.5% 37.5% / 0.2)", "rgba(159, 159, 96, 0.2)", +"hwb(60 37.5% 37.5% / 0.2)", "rgba(159, 159, 96, 0.2)", +"hwb(60deg 37.5% 37.5% / 1)", "rgb(159, 159, 96)", +"hwb(60 37.5% 37.5% / 1)", "rgb(159, 159, 96)", +"hwb(60deg 37.5% 50%)", "rgb(128, 128, 96)", +"hwb(60 37.5% 50%)", "rgb(128, 128, 96)", +"hwb(60deg 37.5% 50% / 0)", "rgba(128, 128, 96, 0)", +"hwb(60 37.5% 50% / 0)", "rgba(128, 128, 96, 0)", +"hwb(60deg 37.5% 50% / 0.2)", "rgba(128, 128, 96, 0.2)", +"hwb(60 37.5% 50% / 0.2)", "rgba(128, 128, 96, 0.2)", +"hwb(60deg 37.5% 50% / 1)", "rgb(128, 128, 96)", +"hwb(60 37.5% 50% / 1)", "rgb(128, 128, 96)", +"hwb(60deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(60 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(60deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(60 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(60deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(60 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(60deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(60 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(60deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(60 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(60deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(60 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(60deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(60 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(60deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(60 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(60deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(60 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(60deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(60 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(60deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(60 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(60deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(60 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(60deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(60 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(60deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(60 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(60deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(60 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(60deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(60 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(60deg 50% 0%)", "rgb(255, 255, 128)", +"hwb(60 50% 0%)", "rgb(255, 255, 128)", +"hwb(60deg 50% 0% / 0)", "rgba(255, 255, 128, 0)", +"hwb(60 50% 0% / 0)", "rgba(255, 255, 128, 0)", +"hwb(60deg 50% 0% / 0.2)", "rgba(255, 255, 128, 0.2)", +"hwb(60 50% 0% / 0.2)", "rgba(255, 255, 128, 0.2)", +"hwb(60deg 50% 0% / 1)", "rgb(255, 255, 128)", +"hwb(60 50% 0% / 1)", "rgb(255, 255, 128)", +"hwb(60deg 50% 12.5%)", "rgb(223, 223, 128)", +"hwb(60 50% 12.5%)", "rgb(223, 223, 128)", +"hwb(60deg 50% 12.5% / 0)", "rgba(223, 223, 128, 0)", +"hwb(60 50% 12.5% / 0)", "rgba(223, 223, 128, 0)", +"hwb(60deg 50% 12.5% / 0.2)", "rgba(223, 223, 128, 0.2)", +"hwb(60 50% 12.5% / 0.2)", "rgba(223, 223, 128, 0.2)", +"hwb(60deg 50% 12.5% / 1)", "rgb(223, 223, 128)", +"hwb(60 50% 12.5% / 1)", "rgb(223, 223, 128)", +"hwb(60deg 50% 25%)", "rgb(191, 191, 128)", +"hwb(60 50% 25%)", "rgb(191, 191, 128)", +"hwb(60deg 50% 25% / 0)", "rgba(191, 191, 128, 0)", +"hwb(60 50% 25% / 0)", "rgba(191, 191, 128, 0)", +"hwb(60deg 50% 25% / 0.2)", "rgba(191, 191, 128, 0.2)", +"hwb(60 50% 25% / 0.2)", "rgba(191, 191, 128, 0.2)", +"hwb(60deg 50% 25% / 1)", "rgb(191, 191, 128)", +"hwb(60 50% 25% / 1)", "rgb(191, 191, 128)", +"hwb(60deg 50% 37.5%)", "rgb(159, 159, 128)", +"hwb(60 50% 37.5%)", "rgb(159, 159, 128)", +"hwb(60deg 50% 37.5% / 0)", "rgba(159, 159, 128, 0)", +"hwb(60 50% 37.5% / 0)", "rgba(159, 159, 128, 0)", +"hwb(60deg 50% 37.5% / 0.2)", "rgba(159, 159, 128, 0.2)", +"hwb(60 50% 37.5% / 0.2)", "rgba(159, 159, 128, 0.2)", +"hwb(60deg 50% 37.5% / 1)", "rgb(159, 159, 128)", +"hwb(60 50% 37.5% / 1)", "rgb(159, 159, 128)", +"hwb(60deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(60 50% 50%)", "rgb(128, 128, 128)", +"hwb(60deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(60 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(60deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(60 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(60deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(60 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(60deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(60 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(60deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(60 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(60deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(60 50% 75%)", "rgb(102, 102, 102)", +"hwb(60deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(60 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(60deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(60 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(60deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(60 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(60deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(60 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(60deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(60 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(60deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(60 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(60deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(60 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(60deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(60 50% 100%)", "rgb(85, 85, 85)", +"hwb(60deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(60 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(60deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(60 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(60deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(60 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(60deg 62.5% 0%)", "rgb(255, 255, 159)", +"hwb(60 62.5% 0%)", "rgb(255, 255, 159)", +"hwb(60deg 62.5% 0% / 0)", "rgba(255, 255, 159, 0)", +"hwb(60 62.5% 0% / 0)", "rgba(255, 255, 159, 0)", +"hwb(60deg 62.5% 0% / 0.2)", "rgba(255, 255, 159, 0.2)", +"hwb(60 62.5% 0% / 0.2)", "rgba(255, 255, 159, 0.2)", +"hwb(60deg 62.5% 0% / 1)", "rgb(255, 255, 159)", +"hwb(60 62.5% 0% / 1)", "rgb(255, 255, 159)", +"hwb(60deg 62.5% 12.5%)", "rgb(223, 223, 159)", +"hwb(60 62.5% 12.5%)", "rgb(223, 223, 159)", +"hwb(60deg 62.5% 12.5% / 0)", "rgba(223, 223, 159, 0)", +"hwb(60 62.5% 12.5% / 0)", "rgba(223, 223, 159, 0)", +"hwb(60deg 62.5% 12.5% / 0.2)", "rgba(223, 223, 159, 0.2)", +"hwb(60 62.5% 12.5% / 0.2)", "rgba(223, 223, 159, 0.2)", +"hwb(60deg 62.5% 12.5% / 1)", "rgb(223, 223, 159)", +"hwb(60 62.5% 12.5% / 1)", "rgb(223, 223, 159)", +"hwb(60deg 62.5% 25%)", "rgb(191, 191, 159)", +"hwb(60 62.5% 25%)", "rgb(191, 191, 159)", +"hwb(60deg 62.5% 25% / 0)", "rgba(191, 191, 159, 0)", +"hwb(60 62.5% 25% / 0)", "rgba(191, 191, 159, 0)", +"hwb(60deg 62.5% 25% / 0.2)", "rgba(191, 191, 159, 0.2)", +"hwb(60 62.5% 25% / 0.2)", "rgba(191, 191, 159, 0.2)", +"hwb(60deg 62.5% 25% / 1)", "rgb(191, 191, 159)", +"hwb(60 62.5% 25% / 1)", "rgb(191, 191, 159)", +"hwb(60deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(60 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(60deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(60 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(60deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(60 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(60deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(60 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(60deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(60 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(60deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(60 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(60deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(60 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(60deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(60 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(60deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(60 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(60deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(60 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(60deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(60 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(60deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(60 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(60deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(60 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(60deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(60 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(60deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(60 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(60deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(60 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(60deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(60 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(60deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(60 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(60deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(60 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(60deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(60 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(60deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(60 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(60deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(60 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(60deg 75% 0%)", "rgb(255, 255, 191)", +"hwb(60 75% 0%)", "rgb(255, 255, 191)", +"hwb(60deg 75% 0% / 0)", "rgba(255, 255, 191, 0)", +"hwb(60 75% 0% / 0)", "rgba(255, 255, 191, 0)", +"hwb(60deg 75% 0% / 0.2)", "rgba(255, 255, 191, 0.2)", +"hwb(60 75% 0% / 0.2)", "rgba(255, 255, 191, 0.2)", +"hwb(60deg 75% 0% / 1)", "rgb(255, 255, 191)", +"hwb(60 75% 0% / 1)", "rgb(255, 255, 191)", +"hwb(60deg 75% 12.5%)", "rgb(223, 223, 191)", +"hwb(60 75% 12.5%)", "rgb(223, 223, 191)", +"hwb(60deg 75% 12.5% / 0)", "rgba(223, 223, 191, 0)", +"hwb(60 75% 12.5% / 0)", "rgba(223, 223, 191, 0)", +"hwb(60deg 75% 12.5% / 0.2)", "rgba(223, 223, 191, 0.2)", +"hwb(60 75% 12.5% / 0.2)", "rgba(223, 223, 191, 0.2)", +"hwb(60deg 75% 12.5% / 1)", "rgb(223, 223, 191)", +"hwb(60 75% 12.5% / 1)", "rgb(223, 223, 191)", +"hwb(60deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(60 75% 25%)", "rgb(191, 191, 191)", +"hwb(60deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(60 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(60deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(60 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(60deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(60 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(60deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(60 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(60deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(60 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(60deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(60 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(60deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(60 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(60deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(60 75% 50%)", "rgb(153, 153, 153)", +"hwb(60deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(60 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(60deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(60 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(60deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(60 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(60deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(60 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(60deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(60 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(60deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(60 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(60deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(60 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(60deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(60 75% 75%)", "rgb(128, 128, 128)", +"hwb(60deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(60 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(60deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(60 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(60deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(60 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(60deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(60 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(60deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(60 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(60deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(60 75% 100%)", "rgb(109, 109, 109)", +"hwb(60deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(60 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(60deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(60 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(60deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(60 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(60deg 87.5% 0%)", "rgb(255, 255, 223)", +"hwb(60 87.5% 0%)", "rgb(255, 255, 223)", +"hwb(60deg 87.5% 0% / 0)", "rgba(255, 255, 223, 0)", +"hwb(60 87.5% 0% / 0)", "rgba(255, 255, 223, 0)", +"hwb(60deg 87.5% 0% / 0.2)", "rgba(255, 255, 223, 0.2)", +"hwb(60 87.5% 0% / 0.2)", "rgba(255, 255, 223, 0.2)", +"hwb(60deg 87.5% 0% / 1)", "rgb(255, 255, 223)", +"hwb(60 87.5% 0% / 1)", "rgb(255, 255, 223)", +"hwb(60deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(60 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(60deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(60 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(60deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(60 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(60deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(60 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(60deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(60 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(60deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(60 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(60deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(60 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(60deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(60 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(60deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(60 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(60deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(60 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(60deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(60 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(60deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(60 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(60deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(60 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(60deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(60 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(60deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(60 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(60deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(60 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(60deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(60 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(60deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(60 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(60deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(60 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(60deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(60 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(60deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(60 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(60deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(60 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(60deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(60 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(60deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(60 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(60deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(60 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(60deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(60 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(60deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(60 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(60deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(60 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(60deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(60 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(60deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(60 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(60deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(60 100% 0%)", "rgb(255, 255, 255)", +"hwb(60deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(60 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(60deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(60 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(60deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(60 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(60deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(60 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(60deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(60 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(60deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(60 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(60deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(60 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(60deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(60 100% 25%)", "rgb(204, 204, 204)", +"hwb(60deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(60 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(60deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(60 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(60deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(60 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(60deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(60 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(60deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(60 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(60deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(60 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(60deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(60 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(60deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(60 100% 50%)", "rgb(170, 170, 170)", +"hwb(60deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(60 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(60deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(60 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(60deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(60 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(60deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(60 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(60deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(60 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(60deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(60 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(60deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(60 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(60deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(60 100% 75%)", "rgb(146, 146, 146)", +"hwb(60deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(60 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(60deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(60 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(60deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(60 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(60deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(60 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(60deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(60 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(60deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(60 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(60deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(60 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(60deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(60 100% 100%)", "rgb(128, 128, 128)", +"hwb(60deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(60deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(60deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(60 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(90deg 0% 0%)", "rgb(128, 255, 0)", +"hwb(90 0% 0%)", "rgb(128, 255, 0)", +"hwb(90deg 0% 0% / 0)", "rgba(128, 255, 0, 0)", +"hwb(90 0% 0% / 0)", "rgba(128, 255, 0, 0)", +"hwb(90deg 0% 0% / 0.2)", "rgba(128, 255, 0, 0.2)", +"hwb(90 0% 0% / 0.2)", "rgba(128, 255, 0, 0.2)", +"hwb(90deg 0% 0% / 1)", "rgb(128, 255, 0)", +"hwb(90 0% 0% / 1)", "rgb(128, 255, 0)", +"hwb(90deg 0% 12.5%)", "rgb(112, 223, 0)", +"hwb(90 0% 12.5%)", "rgb(112, 223, 0)", +"hwb(90deg 0% 12.5% / 0)", "rgba(112, 223, 0, 0)", +"hwb(90 0% 12.5% / 0)", "rgba(112, 223, 0, 0)", +"hwb(90deg 0% 12.5% / 0.2)", "rgba(112, 223, 0, 0.2)", +"hwb(90 0% 12.5% / 0.2)", "rgba(112, 223, 0, 0.2)", +"hwb(90deg 0% 12.5% / 1)", "rgb(112, 223, 0)", +"hwb(90 0% 12.5% / 1)", "rgb(112, 223, 0)", +"hwb(90deg 0% 25%)", "rgb(96, 191, 0)", +"hwb(90 0% 25%)", "rgb(96, 191, 0)", +"hwb(90deg 0% 25% / 0)", "rgba(96, 191, 0, 0)", +"hwb(90 0% 25% / 0)", "rgba(96, 191, 0, 0)", +"hwb(90deg 0% 25% / 0.2)", "rgba(96, 191, 0, 0.2)", +"hwb(90 0% 25% / 0.2)", "rgba(96, 191, 0, 0.2)", +"hwb(90deg 0% 25% / 1)", "rgb(96, 191, 0)", +"hwb(90 0% 25% / 1)", "rgb(96, 191, 0)", +"hwb(90deg 0% 37.5%)", "rgb(80, 159, 0)", +"hwb(90 0% 37.5%)", "rgb(80, 159, 0)", +"hwb(90deg 0% 37.5% / 0)", "rgba(80, 159, 0, 0)", +"hwb(90 0% 37.5% / 0)", "rgba(80, 159, 0, 0)", +"hwb(90deg 0% 37.5% / 0.2)", "rgba(80, 159, 0, 0.2)", +"hwb(90 0% 37.5% / 0.2)", "rgba(80, 159, 0, 0.2)", +"hwb(90deg 0% 37.5% / 1)", "rgb(80, 159, 0)", +"hwb(90 0% 37.5% / 1)", "rgb(80, 159, 0)", +"hwb(90deg 0% 50%)", "rgb(64, 128, 0)", +"hwb(90 0% 50%)", "rgb(64, 128, 0)", +"hwb(90deg 0% 50% / 0)", "rgba(64, 128, 0, 0)", +"hwb(90 0% 50% / 0)", "rgba(64, 128, 0, 0)", +"hwb(90deg 0% 50% / 0.2)", "rgba(64, 128, 0, 0.2)", +"hwb(90 0% 50% / 0.2)", "rgba(64, 128, 0, 0.2)", +"hwb(90deg 0% 50% / 1)", "rgb(64, 128, 0)", +"hwb(90 0% 50% / 1)", "rgb(64, 128, 0)", +"hwb(90deg 0% 62.5%)", "rgb(48, 96, 0)", +"hwb(90 0% 62.5%)", "rgb(48, 96, 0)", +"hwb(90deg 0% 62.5% / 0)", "rgba(48, 96, 0, 0)", +"hwb(90 0% 62.5% / 0)", "rgba(48, 96, 0, 0)", +"hwb(90deg 0% 62.5% / 0.2)", "rgba(48, 96, 0, 0.2)", +"hwb(90 0% 62.5% / 0.2)", "rgba(48, 96, 0, 0.2)", +"hwb(90deg 0% 62.5% / 1)", "rgb(48, 96, 0)", +"hwb(90 0% 62.5% / 1)", "rgb(48, 96, 0)", +"hwb(90deg 0% 75%)", "rgb(32, 64, 0)", +"hwb(90 0% 75%)", "rgb(32, 64, 0)", +"hwb(90deg 0% 75% / 0)", "rgba(32, 64, 0, 0)", +"hwb(90 0% 75% / 0)", "rgba(32, 64, 0, 0)", +"hwb(90deg 0% 75% / 0.2)", "rgba(32, 64, 0, 0.2)", +"hwb(90 0% 75% / 0.2)", "rgba(32, 64, 0, 0.2)", +"hwb(90deg 0% 75% / 1)", "rgb(32, 64, 0)", +"hwb(90 0% 75% / 1)", "rgb(32, 64, 0)", +"hwb(90deg 0% 87.5%)", "rgb(16, 32, 0)", +"hwb(90 0% 87.5%)", "rgb(16, 32, 0)", +"hwb(90deg 0% 87.5% / 0)", "rgba(16, 32, 0, 0)", +"hwb(90 0% 87.5% / 0)", "rgba(16, 32, 0, 0)", +"hwb(90deg 0% 87.5% / 0.2)", "rgba(16, 32, 0, 0.2)", +"hwb(90 0% 87.5% / 0.2)", "rgba(16, 32, 0, 0.2)", +"hwb(90deg 0% 87.5% / 1)", "rgb(16, 32, 0)", +"hwb(90 0% 87.5% / 1)", "rgb(16, 32, 0)", +"hwb(90deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(90 0% 100%)", "rgb(0, 0, 0)", +"hwb(90deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(90 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(90deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(90 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(90deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(90 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(90deg 12.5% 0%)", "rgb(143, 255, 32)", +"hwb(90 12.5% 0%)", "rgb(143, 255, 32)", +"hwb(90deg 12.5% 0% / 0)", "rgba(143, 255, 32, 0)", +"hwb(90 12.5% 0% / 0)", "rgba(143, 255, 32, 0)", +"hwb(90deg 12.5% 0% / 0.2)", "rgba(143, 255, 32, 0.2)", +"hwb(90 12.5% 0% / 0.2)", "rgba(143, 255, 32, 0.2)", +"hwb(90deg 12.5% 0% / 1)", "rgb(143, 255, 32)", +"hwb(90 12.5% 0% / 1)", "rgb(143, 255, 32)", +"hwb(90deg 12.5% 12.5%)", "rgb(128, 223, 32)", +"hwb(90 12.5% 12.5%)", "rgb(128, 223, 32)", +"hwb(90deg 12.5% 12.5% / 0)", "rgba(128, 223, 32, 0)", +"hwb(90 12.5% 12.5% / 0)", "rgba(128, 223, 32, 0)", +"hwb(90deg 12.5% 12.5% / 0.2)", "rgba(128, 223, 32, 0.2)", +"hwb(90 12.5% 12.5% / 0.2)", "rgba(128, 223, 32, 0.2)", +"hwb(90deg 12.5% 12.5% / 1)", "rgb(128, 223, 32)", +"hwb(90 12.5% 12.5% / 1)", "rgb(128, 223, 32)", +"hwb(90deg 12.5% 25%)", "rgb(112, 191, 32)", +"hwb(90 12.5% 25%)", "rgb(112, 191, 32)", +"hwb(90deg 12.5% 25% / 0)", "rgba(112, 191, 32, 0)", +"hwb(90 12.5% 25% / 0)", "rgba(112, 191, 32, 0)", +"hwb(90deg 12.5% 25% / 0.2)", "rgba(112, 191, 32, 0.2)", +"hwb(90 12.5% 25% / 0.2)", "rgba(112, 191, 32, 0.2)", +"hwb(90deg 12.5% 25% / 1)", "rgb(112, 191, 32)", +"hwb(90 12.5% 25% / 1)", "rgb(112, 191, 32)", +"hwb(90deg 12.5% 37.5%)", "rgb(96, 159, 32)", +"hwb(90 12.5% 37.5%)", "rgb(96, 159, 32)", +"hwb(90deg 12.5% 37.5% / 0)", "rgba(96, 159, 32, 0)", +"hwb(90 12.5% 37.5% / 0)", "rgba(96, 159, 32, 0)", +"hwb(90deg 12.5% 37.5% / 0.2)", "rgba(96, 159, 32, 0.2)", +"hwb(90 12.5% 37.5% / 0.2)", "rgba(96, 159, 32, 0.2)", +"hwb(90deg 12.5% 37.5% / 1)", "rgb(96, 159, 32)", +"hwb(90 12.5% 37.5% / 1)", "rgb(96, 159, 32)", +"hwb(90deg 12.5% 50%)", "rgb(80, 128, 32)", +"hwb(90 12.5% 50%)", "rgb(80, 128, 32)", +"hwb(90deg 12.5% 50% / 0)", "rgba(80, 128, 32, 0)", +"hwb(90 12.5% 50% / 0)", "rgba(80, 128, 32, 0)", +"hwb(90deg 12.5% 50% / 0.2)", "rgba(80, 128, 32, 0.2)", +"hwb(90 12.5% 50% / 0.2)", "rgba(80, 128, 32, 0.2)", +"hwb(90deg 12.5% 50% / 1)", "rgb(80, 128, 32)", +"hwb(90 12.5% 50% / 1)", "rgb(80, 128, 32)", +"hwb(90deg 12.5% 62.5%)", "rgb(64, 96, 32)", +"hwb(90 12.5% 62.5%)", "rgb(64, 96, 32)", +"hwb(90deg 12.5% 62.5% / 0)", "rgba(64, 96, 32, 0)", +"hwb(90 12.5% 62.5% / 0)", "rgba(64, 96, 32, 0)", +"hwb(90deg 12.5% 62.5% / 0.2)", "rgba(64, 96, 32, 0.2)", +"hwb(90 12.5% 62.5% / 0.2)", "rgba(64, 96, 32, 0.2)", +"hwb(90deg 12.5% 62.5% / 1)", "rgb(64, 96, 32)", +"hwb(90 12.5% 62.5% / 1)", "rgb(64, 96, 32)", +"hwb(90deg 12.5% 75%)", "rgb(48, 64, 32)", +"hwb(90 12.5% 75%)", "rgb(48, 64, 32)", +"hwb(90deg 12.5% 75% / 0)", "rgba(48, 64, 32, 0)", +"hwb(90 12.5% 75% / 0)", "rgba(48, 64, 32, 0)", +"hwb(90deg 12.5% 75% / 0.2)", "rgba(48, 64, 32, 0.2)", +"hwb(90 12.5% 75% / 0.2)", "rgba(48, 64, 32, 0.2)", +"hwb(90deg 12.5% 75% / 1)", "rgb(48, 64, 32)", +"hwb(90 12.5% 75% / 1)", "rgb(48, 64, 32)", +"hwb(90deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(90 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(90deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(90 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(90deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(90 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(90deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(90 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(90deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(90 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(90deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(90 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(90deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(90 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(90deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(90 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(90deg 25% 0%)", "rgb(159, 255, 64)", +"hwb(90 25% 0%)", "rgb(159, 255, 64)", +"hwb(90deg 25% 0% / 0)", "rgba(159, 255, 64, 0)", +"hwb(90 25% 0% / 0)", "rgba(159, 255, 64, 0)", +"hwb(90deg 25% 0% / 0.2)", "rgba(159, 255, 64, 0.2)", +"hwb(90 25% 0% / 0.2)", "rgba(159, 255, 64, 0.2)", +"hwb(90deg 25% 0% / 1)", "rgb(159, 255, 64)", +"hwb(90 25% 0% / 1)", "rgb(159, 255, 64)", +"hwb(90deg 25% 12.5%)", "rgb(143, 223, 64)", +"hwb(90 25% 12.5%)", "rgb(143, 223, 64)", +"hwb(90deg 25% 12.5% / 0)", "rgba(143, 223, 64, 0)", +"hwb(90 25% 12.5% / 0)", "rgba(143, 223, 64, 0)", +"hwb(90deg 25% 12.5% / 0.2)", "rgba(143, 223, 64, 0.2)", +"hwb(90 25% 12.5% / 0.2)", "rgba(143, 223, 64, 0.2)", +"hwb(90deg 25% 12.5% / 1)", "rgb(143, 223, 64)", +"hwb(90 25% 12.5% / 1)", "rgb(143, 223, 64)", +"hwb(90deg 25% 25%)", "rgb(128, 191, 64)", +"hwb(90 25% 25%)", "rgb(128, 191, 64)", +"hwb(90deg 25% 25% / 0)", "rgba(128, 191, 64, 0)", +"hwb(90 25% 25% / 0)", "rgba(128, 191, 64, 0)", +"hwb(90deg 25% 25% / 0.2)", "rgba(128, 191, 64, 0.2)", +"hwb(90 25% 25% / 0.2)", "rgba(128, 191, 64, 0.2)", +"hwb(90deg 25% 25% / 1)", "rgb(128, 191, 64)", +"hwb(90 25% 25% / 1)", "rgb(128, 191, 64)", +"hwb(90deg 25% 37.5%)", "rgb(112, 159, 64)", +"hwb(90 25% 37.5%)", "rgb(112, 159, 64)", +"hwb(90deg 25% 37.5% / 0)", "rgba(112, 159, 64, 0)", +"hwb(90 25% 37.5% / 0)", "rgba(112, 159, 64, 0)", +"hwb(90deg 25% 37.5% / 0.2)", "rgba(112, 159, 64, 0.2)", +"hwb(90 25% 37.5% / 0.2)", "rgba(112, 159, 64, 0.2)", +"hwb(90deg 25% 37.5% / 1)", "rgb(112, 159, 64)", +"hwb(90 25% 37.5% / 1)", "rgb(112, 159, 64)", +"hwb(90deg 25% 50%)", "rgb(96, 128, 64)", +"hwb(90 25% 50%)", "rgb(96, 128, 64)", +"hwb(90deg 25% 50% / 0)", "rgba(96, 128, 64, 0)", +"hwb(90 25% 50% / 0)", "rgba(96, 128, 64, 0)", +"hwb(90deg 25% 50% / 0.2)", "rgba(96, 128, 64, 0.2)", +"hwb(90 25% 50% / 0.2)", "rgba(96, 128, 64, 0.2)", +"hwb(90deg 25% 50% / 1)", "rgb(96, 128, 64)", +"hwb(90 25% 50% / 1)", "rgb(96, 128, 64)", +"hwb(90deg 25% 62.5%)", "rgb(80, 96, 64)", +"hwb(90 25% 62.5%)", "rgb(80, 96, 64)", +"hwb(90deg 25% 62.5% / 0)", "rgba(80, 96, 64, 0)", +"hwb(90 25% 62.5% / 0)", "rgba(80, 96, 64, 0)", +"hwb(90deg 25% 62.5% / 0.2)", "rgba(80, 96, 64, 0.2)", +"hwb(90 25% 62.5% / 0.2)", "rgba(80, 96, 64, 0.2)", +"hwb(90deg 25% 62.5% / 1)", "rgb(80, 96, 64)", +"hwb(90 25% 62.5% / 1)", "rgb(80, 96, 64)", +"hwb(90deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(90 25% 75%)", "rgb(64, 64, 64)", +"hwb(90deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(90 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(90deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(90 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(90deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(90 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(90deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(90 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(90deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(90 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(90deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(90 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(90deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(90 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(90deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(90 25% 100%)", "rgb(51, 51, 51)", +"hwb(90deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(90 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(90deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(90 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(90deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(90 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(90deg 37.5% 0%)", "rgb(175, 255, 96)", +"hwb(90 37.5% 0%)", "rgb(175, 255, 96)", +"hwb(90deg 37.5% 0% / 0)", "rgba(175, 255, 96, 0)", +"hwb(90 37.5% 0% / 0)", "rgba(175, 255, 96, 0)", +"hwb(90deg 37.5% 0% / 0.2)", "rgba(175, 255, 96, 0.2)", +"hwb(90 37.5% 0% / 0.2)", "rgba(175, 255, 96, 0.2)", +"hwb(90deg 37.5% 0% / 1)", "rgb(175, 255, 96)", +"hwb(90 37.5% 0% / 1)", "rgb(175, 255, 96)", +"hwb(90deg 37.5% 12.5%)", "rgb(159, 223, 96)", +"hwb(90 37.5% 12.5%)", "rgb(159, 223, 96)", +"hwb(90deg 37.5% 12.5% / 0)", "rgba(159, 223, 96, 0)", +"hwb(90 37.5% 12.5% / 0)", "rgba(159, 223, 96, 0)", +"hwb(90deg 37.5% 12.5% / 0.2)", "rgba(159, 223, 96, 0.2)", +"hwb(90 37.5% 12.5% / 0.2)", "rgba(159, 223, 96, 0.2)", +"hwb(90deg 37.5% 12.5% / 1)", "rgb(159, 223, 96)", +"hwb(90 37.5% 12.5% / 1)", "rgb(159, 223, 96)", +"hwb(90deg 37.5% 25%)", "rgb(143, 191, 96)", +"hwb(90 37.5% 25%)", "rgb(143, 191, 96)", +"hwb(90deg 37.5% 25% / 0)", "rgba(143, 191, 96, 0)", +"hwb(90 37.5% 25% / 0)", "rgba(143, 191, 96, 0)", +"hwb(90deg 37.5% 25% / 0.2)", "rgba(143, 191, 96, 0.2)", +"hwb(90 37.5% 25% / 0.2)", "rgba(143, 191, 96, 0.2)", +"hwb(90deg 37.5% 25% / 1)", "rgb(143, 191, 96)", +"hwb(90 37.5% 25% / 1)", "rgb(143, 191, 96)", +"hwb(90deg 37.5% 37.5%)", "rgb(128, 159, 96)", +"hwb(90 37.5% 37.5%)", "rgb(128, 159, 96)", +"hwb(90deg 37.5% 37.5% / 0)", "rgba(128, 159, 96, 0)", +"hwb(90 37.5% 37.5% / 0)", "rgba(128, 159, 96, 0)", +"hwb(90deg 37.5% 37.5% / 0.2)", "rgba(128, 159, 96, 0.2)", +"hwb(90 37.5% 37.5% / 0.2)", "rgba(128, 159, 96, 0.2)", +"hwb(90deg 37.5% 37.5% / 1)", "rgb(128, 159, 96)", +"hwb(90 37.5% 37.5% / 1)", "rgb(128, 159, 96)", +"hwb(90deg 37.5% 50%)", "rgb(112, 128, 96)", +"hwb(90 37.5% 50%)", "rgb(112, 128, 96)", +"hwb(90deg 37.5% 50% / 0)", "rgba(112, 128, 96, 0)", +"hwb(90 37.5% 50% / 0)", "rgba(112, 128, 96, 0)", +"hwb(90deg 37.5% 50% / 0.2)", "rgba(112, 128, 96, 0.2)", +"hwb(90 37.5% 50% / 0.2)", "rgba(112, 128, 96, 0.2)", +"hwb(90deg 37.5% 50% / 1)", "rgb(112, 128, 96)", +"hwb(90 37.5% 50% / 1)", "rgb(112, 128, 96)", +"hwb(90deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(90 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(90deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(90 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(90deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(90 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(90deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(90 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(90deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(90 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(90deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(90 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(90deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(90 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(90deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(90 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(90deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(90 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(90deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(90 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(90deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(90 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(90deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(90 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(90deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(90 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(90deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(90 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(90deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(90 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(90deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(90 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(90deg 50% 0%)", "rgb(191, 255, 128)", +"hwb(90 50% 0%)", "rgb(191, 255, 128)", +"hwb(90deg 50% 0% / 0)", "rgba(191, 255, 128, 0)", +"hwb(90 50% 0% / 0)", "rgba(191, 255, 128, 0)", +"hwb(90deg 50% 0% / 0.2)", "rgba(191, 255, 128, 0.2)", +"hwb(90 50% 0% / 0.2)", "rgba(191, 255, 128, 0.2)", +"hwb(90deg 50% 0% / 1)", "rgb(191, 255, 128)", +"hwb(90 50% 0% / 1)", "rgb(191, 255, 128)", +"hwb(90deg 50% 12.5%)", "rgb(175, 223, 128)", +"hwb(90 50% 12.5%)", "rgb(175, 223, 128)", +"hwb(90deg 50% 12.5% / 0)", "rgba(175, 223, 128, 0)", +"hwb(90 50% 12.5% / 0)", "rgba(175, 223, 128, 0)", +"hwb(90deg 50% 12.5% / 0.2)", "rgba(175, 223, 128, 0.2)", +"hwb(90 50% 12.5% / 0.2)", "rgba(175, 223, 128, 0.2)", +"hwb(90deg 50% 12.5% / 1)", "rgb(175, 223, 128)", +"hwb(90 50% 12.5% / 1)", "rgb(175, 223, 128)", +"hwb(90deg 50% 25%)", "rgb(159, 191, 128)", +"hwb(90 50% 25%)", "rgb(159, 191, 128)", +"hwb(90deg 50% 25% / 0)", "rgba(159, 191, 128, 0)", +"hwb(90 50% 25% / 0)", "rgba(159, 191, 128, 0)", +"hwb(90deg 50% 25% / 0.2)", "rgba(159, 191, 128, 0.2)", +"hwb(90 50% 25% / 0.2)", "rgba(159, 191, 128, 0.2)", +"hwb(90deg 50% 25% / 1)", "rgb(159, 191, 128)", +"hwb(90 50% 25% / 1)", "rgb(159, 191, 128)", +"hwb(90deg 50% 37.5%)", "rgb(143, 159, 128)", +"hwb(90 50% 37.5%)", "rgb(143, 159, 128)", +"hwb(90deg 50% 37.5% / 0)", "rgba(143, 159, 128, 0)", +"hwb(90 50% 37.5% / 0)", "rgba(143, 159, 128, 0)", +"hwb(90deg 50% 37.5% / 0.2)", "rgba(143, 159, 128, 0.2)", +"hwb(90 50% 37.5% / 0.2)", "rgba(143, 159, 128, 0.2)", +"hwb(90deg 50% 37.5% / 1)", "rgb(143, 159, 128)", +"hwb(90 50% 37.5% / 1)", "rgb(143, 159, 128)", +"hwb(90deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(90 50% 50%)", "rgb(128, 128, 128)", +"hwb(90deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(90 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(90deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(90 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(90deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(90 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(90deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(90 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(90deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(90 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(90deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(90 50% 75%)", "rgb(102, 102, 102)", +"hwb(90deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(90 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(90deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(90 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(90deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(90 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(90deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(90 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(90deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(90 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(90deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(90 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(90deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(90 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(90deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(90 50% 100%)", "rgb(85, 85, 85)", +"hwb(90deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(90 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(90deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(90 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(90deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(90 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(90deg 62.5% 0%)", "rgb(207, 255, 159)", +"hwb(90 62.5% 0%)", "rgb(207, 255, 159)", +"hwb(90deg 62.5% 0% / 0)", "rgba(207, 255, 159, 0)", +"hwb(90 62.5% 0% / 0)", "rgba(207, 255, 159, 0)", +"hwb(90deg 62.5% 0% / 0.2)", "rgba(207, 255, 159, 0.2)", +"hwb(90 62.5% 0% / 0.2)", "rgba(207, 255, 159, 0.2)", +"hwb(90deg 62.5% 0% / 1)", "rgb(207, 255, 159)", +"hwb(90 62.5% 0% / 1)", "rgb(207, 255, 159)", +"hwb(90deg 62.5% 12.5%)", "rgb(191, 223, 159)", +"hwb(90 62.5% 12.5%)", "rgb(191, 223, 159)", +"hwb(90deg 62.5% 12.5% / 0)", "rgba(191, 223, 159, 0)", +"hwb(90 62.5% 12.5% / 0)", "rgba(191, 223, 159, 0)", +"hwb(90deg 62.5% 12.5% / 0.2)", "rgba(191, 223, 159, 0.2)", +"hwb(90 62.5% 12.5% / 0.2)", "rgba(191, 223, 159, 0.2)", +"hwb(90deg 62.5% 12.5% / 1)", "rgb(191, 223, 159)", +"hwb(90 62.5% 12.5% / 1)", "rgb(191, 223, 159)", +"hwb(90deg 62.5% 25%)", "rgb(175, 191, 159)", +"hwb(90 62.5% 25%)", "rgb(175, 191, 159)", +"hwb(90deg 62.5% 25% / 0)", "rgba(175, 191, 159, 0)", +"hwb(90 62.5% 25% / 0)", "rgba(175, 191, 159, 0)", +"hwb(90deg 62.5% 25% / 0.2)", "rgba(175, 191, 159, 0.2)", +"hwb(90 62.5% 25% / 0.2)", "rgba(175, 191, 159, 0.2)", +"hwb(90deg 62.5% 25% / 1)", "rgb(175, 191, 159)", +"hwb(90 62.5% 25% / 1)", "rgb(175, 191, 159)", +"hwb(90deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(90 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(90deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(90 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(90deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(90 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(90deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(90 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(90deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(90 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(90deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(90 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(90deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(90 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(90deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(90 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(90deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(90 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(90deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(90 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(90deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(90 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(90deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(90 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(90deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(90 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(90deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(90 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(90deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(90 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(90deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(90 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(90deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(90 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(90deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(90 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(90deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(90 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(90deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(90 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(90deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(90 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(90deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(90 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(90deg 75% 0%)", "rgb(223, 255, 191)", +"hwb(90 75% 0%)", "rgb(223, 255, 191)", +"hwb(90deg 75% 0% / 0)", "rgba(223, 255, 191, 0)", +"hwb(90 75% 0% / 0)", "rgba(223, 255, 191, 0)", +"hwb(90deg 75% 0% / 0.2)", "rgba(223, 255, 191, 0.2)", +"hwb(90 75% 0% / 0.2)", "rgba(223, 255, 191, 0.2)", +"hwb(90deg 75% 0% / 1)", "rgb(223, 255, 191)", +"hwb(90 75% 0% / 1)", "rgb(223, 255, 191)", +"hwb(90deg 75% 12.5%)", "rgb(207, 223, 191)", +"hwb(90 75% 12.5%)", "rgb(207, 223, 191)", +"hwb(90deg 75% 12.5% / 0)", "rgba(207, 223, 191, 0)", +"hwb(90 75% 12.5% / 0)", "rgba(207, 223, 191, 0)", +"hwb(90deg 75% 12.5% / 0.2)", "rgba(207, 223, 191, 0.2)", +"hwb(90 75% 12.5% / 0.2)", "rgba(207, 223, 191, 0.2)", +"hwb(90deg 75% 12.5% / 1)", "rgb(207, 223, 191)", +"hwb(90 75% 12.5% / 1)", "rgb(207, 223, 191)", +"hwb(90deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(90 75% 25%)", "rgb(191, 191, 191)", +"hwb(90deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(90 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(90deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(90 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(90deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(90 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(90deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(90 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(90deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(90 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(90deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(90 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(90deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(90 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(90deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(90 75% 50%)", "rgb(153, 153, 153)", +"hwb(90deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(90 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(90deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(90 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(90deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(90 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(90deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(90 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(90deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(90 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(90deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(90 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(90deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(90 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(90deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(90 75% 75%)", "rgb(128, 128, 128)", +"hwb(90deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(90 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(90deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(90 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(90deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(90 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(90deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(90 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(90deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(90 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(90deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(90 75% 100%)", "rgb(109, 109, 109)", +"hwb(90deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(90 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(90deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(90 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(90deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(90 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(90deg 87.5% 0%)", "rgb(239, 255, 223)", +"hwb(90 87.5% 0%)", "rgb(239, 255, 223)", +"hwb(90deg 87.5% 0% / 0)", "rgba(239, 255, 223, 0)", +"hwb(90 87.5% 0% / 0)", "rgba(239, 255, 223, 0)", +"hwb(90deg 87.5% 0% / 0.2)", "rgba(239, 255, 223, 0.2)", +"hwb(90 87.5% 0% / 0.2)", "rgba(239, 255, 223, 0.2)", +"hwb(90deg 87.5% 0% / 1)", "rgb(239, 255, 223)", +"hwb(90 87.5% 0% / 1)", "rgb(239, 255, 223)", +"hwb(90deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(90 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(90deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(90 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(90deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(90 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(90deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(90 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(90deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(90 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(90deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(90 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(90deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(90 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(90deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(90 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(90deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(90 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(90deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(90 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(90deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(90 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(90deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(90 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(90deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(90 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(90deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(90 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(90deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(90 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(90deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(90 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(90deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(90 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(90deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(90 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(90deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(90 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(90deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(90 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(90deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(90 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(90deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(90 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(90deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(90 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(90deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(90 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(90deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(90 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(90deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(90 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(90deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(90 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(90deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(90 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(90deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(90 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(90deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(90 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(90deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(90 100% 0%)", "rgb(255, 255, 255)", +"hwb(90deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(90 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(90deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(90 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(90deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(90 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(90deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(90 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(90deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(90 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(90deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(90 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(90deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(90 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(90deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(90 100% 25%)", "rgb(204, 204, 204)", +"hwb(90deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(90 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(90deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(90 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(90deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(90 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(90deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(90 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(90deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(90 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(90deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(90 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(90deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(90 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(90deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(90 100% 50%)", "rgb(170, 170, 170)", +"hwb(90deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(90 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(90deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(90 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(90deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(90 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(90deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(90 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(90deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(90 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(90deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(90 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(90deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(90 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(90deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(90 100% 75%)", "rgb(146, 146, 146)", +"hwb(90deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(90 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(90deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(90 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(90deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(90 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(90deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(90 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(90deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(90 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(90deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(90 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(90deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(90 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(90deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(90 100% 100%)", "rgb(128, 128, 128)", +"hwb(90deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(90deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(90deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(90 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(120deg 0% 0%)", "rgb(0, 255, 0)", +"hwb(120 0% 0%)", "rgb(0, 255, 0)", +"hwb(120deg 0% 0% / 0)", "rgba(0, 255, 0, 0)", +"hwb(120 0% 0% / 0)", "rgba(0, 255, 0, 0)", +"hwb(120deg 0% 0% / 0.2)", "rgba(0, 255, 0, 0.2)", +"hwb(120 0% 0% / 0.2)", "rgba(0, 255, 0, 0.2)", +"hwb(120deg 0% 0% / 1)", "rgb(0, 255, 0)", +"hwb(120 0% 0% / 1)", "rgb(0, 255, 0)", +"hwb(120deg 0% 12.5%)", "rgb(0, 223, 0)", +"hwb(120 0% 12.5%)", "rgb(0, 223, 0)", +"hwb(120deg 0% 12.5% / 0)", "rgba(0, 223, 0, 0)", +"hwb(120 0% 12.5% / 0)", "rgba(0, 223, 0, 0)", +"hwb(120deg 0% 12.5% / 0.2)", "rgba(0, 223, 0, 0.2)", +"hwb(120 0% 12.5% / 0.2)", "rgba(0, 223, 0, 0.2)", +"hwb(120deg 0% 12.5% / 1)", "rgb(0, 223, 0)", +"hwb(120 0% 12.5% / 1)", "rgb(0, 223, 0)", +"hwb(120deg 0% 25%)", "rgb(0, 191, 0)", +"hwb(120 0% 25%)", "rgb(0, 191, 0)", +"hwb(120deg 0% 25% / 0)", "rgba(0, 191, 0, 0)", +"hwb(120 0% 25% / 0)", "rgba(0, 191, 0, 0)", +"hwb(120deg 0% 25% / 0.2)", "rgba(0, 191, 0, 0.2)", +"hwb(120 0% 25% / 0.2)", "rgba(0, 191, 0, 0.2)", +"hwb(120deg 0% 25% / 1)", "rgb(0, 191, 0)", +"hwb(120 0% 25% / 1)", "rgb(0, 191, 0)", +"hwb(120deg 0% 37.5%)", "rgb(0, 159, 0)", +"hwb(120 0% 37.5%)", "rgb(0, 159, 0)", +"hwb(120deg 0% 37.5% / 0)", "rgba(0, 159, 0, 0)", +"hwb(120 0% 37.5% / 0)", "rgba(0, 159, 0, 0)", +"hwb(120deg 0% 37.5% / 0.2)", "rgba(0, 159, 0, 0.2)", +"hwb(120 0% 37.5% / 0.2)", "rgba(0, 159, 0, 0.2)", +"hwb(120deg 0% 37.5% / 1)", "rgb(0, 159, 0)", +"hwb(120 0% 37.5% / 1)", "rgb(0, 159, 0)", +"hwb(120deg 0% 50%)", "rgb(0, 128, 0)", +"hwb(120 0% 50%)", "rgb(0, 128, 0)", +"hwb(120deg 0% 50% / 0)", "rgba(0, 128, 0, 0)", +"hwb(120 0% 50% / 0)", "rgba(0, 128, 0, 0)", +"hwb(120deg 0% 50% / 0.2)", "rgba(0, 128, 0, 0.2)", +"hwb(120 0% 50% / 0.2)", "rgba(0, 128, 0, 0.2)", +"hwb(120deg 0% 50% / 1)", "rgb(0, 128, 0)", +"hwb(120 0% 50% / 1)", "rgb(0, 128, 0)", +"hwb(120deg 0% 62.5%)", "rgb(0, 96, 0)", +"hwb(120 0% 62.5%)", "rgb(0, 96, 0)", +"hwb(120deg 0% 62.5% / 0)", "rgba(0, 96, 0, 0)", +"hwb(120 0% 62.5% / 0)", "rgba(0, 96, 0, 0)", +"hwb(120deg 0% 62.5% / 0.2)", "rgba(0, 96, 0, 0.2)", +"hwb(120 0% 62.5% / 0.2)", "rgba(0, 96, 0, 0.2)", +"hwb(120deg 0% 62.5% / 1)", "rgb(0, 96, 0)", +"hwb(120 0% 62.5% / 1)", "rgb(0, 96, 0)", +"hwb(120deg 0% 75%)", "rgb(0, 64, 0)", +"hwb(120 0% 75%)", "rgb(0, 64, 0)", +"hwb(120deg 0% 75% / 0)", "rgba(0, 64, 0, 0)", +"hwb(120 0% 75% / 0)", "rgba(0, 64, 0, 0)", +"hwb(120deg 0% 75% / 0.2)", "rgba(0, 64, 0, 0.2)", +"hwb(120 0% 75% / 0.2)", "rgba(0, 64, 0, 0.2)", +"hwb(120deg 0% 75% / 1)", "rgb(0, 64, 0)", +"hwb(120 0% 75% / 1)", "rgb(0, 64, 0)", +"hwb(120deg 0% 87.5%)", "rgb(0, 32, 0)", +"hwb(120 0% 87.5%)", "rgb(0, 32, 0)", +"hwb(120deg 0% 87.5% / 0)", "rgba(0, 32, 0, 0)", +"hwb(120 0% 87.5% / 0)", "rgba(0, 32, 0, 0)", +"hwb(120deg 0% 87.5% / 0.2)", "rgba(0, 32, 0, 0.2)", +"hwb(120 0% 87.5% / 0.2)", "rgba(0, 32, 0, 0.2)", +"hwb(120deg 0% 87.5% / 1)", "rgb(0, 32, 0)", +"hwb(120 0% 87.5% / 1)", "rgb(0, 32, 0)", +"hwb(120deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(120 0% 100%)", "rgb(0, 0, 0)", +"hwb(120deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(120 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(120deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(120 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(120deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(120 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(120deg 12.5% 0%)", "rgb(32, 255, 32)", +"hwb(120 12.5% 0%)", "rgb(32, 255, 32)", +"hwb(120deg 12.5% 0% / 0)", "rgba(32, 255, 32, 0)", +"hwb(120 12.5% 0% / 0)", "rgba(32, 255, 32, 0)", +"hwb(120deg 12.5% 0% / 0.2)", "rgba(32, 255, 32, 0.2)", +"hwb(120 12.5% 0% / 0.2)", "rgba(32, 255, 32, 0.2)", +"hwb(120deg 12.5% 0% / 1)", "rgb(32, 255, 32)", +"hwb(120 12.5% 0% / 1)", "rgb(32, 255, 32)", +"hwb(120deg 12.5% 12.5%)", "rgb(32, 223, 32)", +"hwb(120 12.5% 12.5%)", "rgb(32, 223, 32)", +"hwb(120deg 12.5% 12.5% / 0)", "rgba(32, 223, 32, 0)", +"hwb(120 12.5% 12.5% / 0)", "rgba(32, 223, 32, 0)", +"hwb(120deg 12.5% 12.5% / 0.2)", "rgba(32, 223, 32, 0.2)", +"hwb(120 12.5% 12.5% / 0.2)", "rgba(32, 223, 32, 0.2)", +"hwb(120deg 12.5% 12.5% / 1)", "rgb(32, 223, 32)", +"hwb(120 12.5% 12.5% / 1)", "rgb(32, 223, 32)", +"hwb(120deg 12.5% 25%)", "rgb(32, 191, 32)", +"hwb(120 12.5% 25%)", "rgb(32, 191, 32)", +"hwb(120deg 12.5% 25% / 0)", "rgba(32, 191, 32, 0)", +"hwb(120 12.5% 25% / 0)", "rgba(32, 191, 32, 0)", +"hwb(120deg 12.5% 25% / 0.2)", "rgba(32, 191, 32, 0.2)", +"hwb(120 12.5% 25% / 0.2)", "rgba(32, 191, 32, 0.2)", +"hwb(120deg 12.5% 25% / 1)", "rgb(32, 191, 32)", +"hwb(120 12.5% 25% / 1)", "rgb(32, 191, 32)", +"hwb(120deg 12.5% 37.5%)", "rgb(32, 159, 32)", +"hwb(120 12.5% 37.5%)", "rgb(32, 159, 32)", +"hwb(120deg 12.5% 37.5% / 0)", "rgba(32, 159, 32, 0)", +"hwb(120 12.5% 37.5% / 0)", "rgba(32, 159, 32, 0)", +"hwb(120deg 12.5% 37.5% / 0.2)", "rgba(32, 159, 32, 0.2)", +"hwb(120 12.5% 37.5% / 0.2)", "rgba(32, 159, 32, 0.2)", +"hwb(120deg 12.5% 37.5% / 1)", "rgb(32, 159, 32)", +"hwb(120 12.5% 37.5% / 1)", "rgb(32, 159, 32)", +"hwb(120deg 12.5% 50%)", "rgb(32, 128, 32)", +"hwb(120 12.5% 50%)", "rgb(32, 128, 32)", +"hwb(120deg 12.5% 50% / 0)", "rgba(32, 128, 32, 0)", +"hwb(120 12.5% 50% / 0)", "rgba(32, 128, 32, 0)", +"hwb(120deg 12.5% 50% / 0.2)", "rgba(32, 128, 32, 0.2)", +"hwb(120 12.5% 50% / 0.2)", "rgba(32, 128, 32, 0.2)", +"hwb(120deg 12.5% 50% / 1)", "rgb(32, 128, 32)", +"hwb(120 12.5% 50% / 1)", "rgb(32, 128, 32)", +"hwb(120deg 12.5% 62.5%)", "rgb(32, 96, 32)", +"hwb(120 12.5% 62.5%)", "rgb(32, 96, 32)", +"hwb(120deg 12.5% 62.5% / 0)", "rgba(32, 96, 32, 0)", +"hwb(120 12.5% 62.5% / 0)", "rgba(32, 96, 32, 0)", +"hwb(120deg 12.5% 62.5% / 0.2)", "rgba(32, 96, 32, 0.2)", +"hwb(120 12.5% 62.5% / 0.2)", "rgba(32, 96, 32, 0.2)", +"hwb(120deg 12.5% 62.5% / 1)", "rgb(32, 96, 32)", +"hwb(120 12.5% 62.5% / 1)", "rgb(32, 96, 32)", +"hwb(120deg 12.5% 75%)", "rgb(32, 64, 32)", +"hwb(120 12.5% 75%)", "rgb(32, 64, 32)", +"hwb(120deg 12.5% 75% / 0)", "rgba(32, 64, 32, 0)", +"hwb(120 12.5% 75% / 0)", "rgba(32, 64, 32, 0)", +"hwb(120deg 12.5% 75% / 0.2)", "rgba(32, 64, 32, 0.2)", +"hwb(120 12.5% 75% / 0.2)", "rgba(32, 64, 32, 0.2)", +"hwb(120deg 12.5% 75% / 1)", "rgb(32, 64, 32)", +"hwb(120 12.5% 75% / 1)", "rgb(32, 64, 32)", +"hwb(120deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(120 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(120deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(120 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(120deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(120 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(120deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(120 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(120deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(120 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(120deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(120 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(120deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(120 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(120deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(120 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(120deg 25% 0%)", "rgb(64, 255, 64)", +"hwb(120 25% 0%)", "rgb(64, 255, 64)", +"hwb(120deg 25% 0% / 0)", "rgba(64, 255, 64, 0)", +"hwb(120 25% 0% / 0)", "rgba(64, 255, 64, 0)", +"hwb(120deg 25% 0% / 0.2)", "rgba(64, 255, 64, 0.2)", +"hwb(120 25% 0% / 0.2)", "rgba(64, 255, 64, 0.2)", +"hwb(120deg 25% 0% / 1)", "rgb(64, 255, 64)", +"hwb(120 25% 0% / 1)", "rgb(64, 255, 64)", +"hwb(120deg 25% 12.5%)", "rgb(64, 223, 64)", +"hwb(120 25% 12.5%)", "rgb(64, 223, 64)", +"hwb(120deg 25% 12.5% / 0)", "rgba(64, 223, 64, 0)", +"hwb(120 25% 12.5% / 0)", "rgba(64, 223, 64, 0)", +"hwb(120deg 25% 12.5% / 0.2)", "rgba(64, 223, 64, 0.2)", +"hwb(120 25% 12.5% / 0.2)", "rgba(64, 223, 64, 0.2)", +"hwb(120deg 25% 12.5% / 1)", "rgb(64, 223, 64)", +"hwb(120 25% 12.5% / 1)", "rgb(64, 223, 64)", +"hwb(120deg 25% 25%)", "rgb(64, 191, 64)", +"hwb(120 25% 25%)", "rgb(64, 191, 64)", +"hwb(120deg 25% 25% / 0)", "rgba(64, 191, 64, 0)", +"hwb(120 25% 25% / 0)", "rgba(64, 191, 64, 0)", +"hwb(120deg 25% 25% / 0.2)", "rgba(64, 191, 64, 0.2)", +"hwb(120 25% 25% / 0.2)", "rgba(64, 191, 64, 0.2)", +"hwb(120deg 25% 25% / 1)", "rgb(64, 191, 64)", +"hwb(120 25% 25% / 1)", "rgb(64, 191, 64)", +"hwb(120deg 25% 37.5%)", "rgb(64, 159, 64)", +"hwb(120 25% 37.5%)", "rgb(64, 159, 64)", +"hwb(120deg 25% 37.5% / 0)", "rgba(64, 159, 64, 0)", +"hwb(120 25% 37.5% / 0)", "rgba(64, 159, 64, 0)", +"hwb(120deg 25% 37.5% / 0.2)", "rgba(64, 159, 64, 0.2)", +"hwb(120 25% 37.5% / 0.2)", "rgba(64, 159, 64, 0.2)", +"hwb(120deg 25% 37.5% / 1)", "rgb(64, 159, 64)", +"hwb(120 25% 37.5% / 1)", "rgb(64, 159, 64)", +"hwb(120deg 25% 50%)", "rgb(64, 128, 64)", +"hwb(120 25% 50%)", "rgb(64, 128, 64)", +"hwb(120deg 25% 50% / 0)", "rgba(64, 128, 64, 0)", +"hwb(120 25% 50% / 0)", "rgba(64, 128, 64, 0)", +"hwb(120deg 25% 50% / 0.2)", "rgba(64, 128, 64, 0.2)", +"hwb(120 25% 50% / 0.2)", "rgba(64, 128, 64, 0.2)", +"hwb(120deg 25% 50% / 1)", "rgb(64, 128, 64)", +"hwb(120 25% 50% / 1)", "rgb(64, 128, 64)", +"hwb(120deg 25% 62.5%)", "rgb(64, 96, 64)", +"hwb(120 25% 62.5%)", "rgb(64, 96, 64)", +"hwb(120deg 25% 62.5% / 0)", "rgba(64, 96, 64, 0)", +"hwb(120 25% 62.5% / 0)", "rgba(64, 96, 64, 0)", +"hwb(120deg 25% 62.5% / 0.2)", "rgba(64, 96, 64, 0.2)", +"hwb(120 25% 62.5% / 0.2)", "rgba(64, 96, 64, 0.2)", +"hwb(120deg 25% 62.5% / 1)", "rgb(64, 96, 64)", +"hwb(120 25% 62.5% / 1)", "rgb(64, 96, 64)", +"hwb(120deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(120 25% 75%)", "rgb(64, 64, 64)", +"hwb(120deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(120 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(120deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(120 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(120deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(120 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(120deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(120 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(120deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(120 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(120deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(120 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(120deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(120 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(120deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(120 25% 100%)", "rgb(51, 51, 51)", +"hwb(120deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(120 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(120deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(120 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(120deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(120 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(120deg 37.5% 0%)", "rgb(96, 255, 96)", +"hwb(120 37.5% 0%)", "rgb(96, 255, 96)", +"hwb(120deg 37.5% 0% / 0)", "rgba(96, 255, 96, 0)", +"hwb(120 37.5% 0% / 0)", "rgba(96, 255, 96, 0)", +"hwb(120deg 37.5% 0% / 0.2)", "rgba(96, 255, 96, 0.2)", +"hwb(120 37.5% 0% / 0.2)", "rgba(96, 255, 96, 0.2)", +"hwb(120deg 37.5% 0% / 1)", "rgb(96, 255, 96)", +"hwb(120 37.5% 0% / 1)", "rgb(96, 255, 96)", +"hwb(120deg 37.5% 12.5%)", "rgb(96, 223, 96)", +"hwb(120 37.5% 12.5%)", "rgb(96, 223, 96)", +"hwb(120deg 37.5% 12.5% / 0)", "rgba(96, 223, 96, 0)", +"hwb(120 37.5% 12.5% / 0)", "rgba(96, 223, 96, 0)", +"hwb(120deg 37.5% 12.5% / 0.2)", "rgba(96, 223, 96, 0.2)", +"hwb(120 37.5% 12.5% / 0.2)", "rgba(96, 223, 96, 0.2)", +"hwb(120deg 37.5% 12.5% / 1)", "rgb(96, 223, 96)", +"hwb(120 37.5% 12.5% / 1)", "rgb(96, 223, 96)", +"hwb(120deg 37.5% 25%)", "rgb(96, 191, 96)", +"hwb(120 37.5% 25%)", "rgb(96, 191, 96)", +"hwb(120deg 37.5% 25% / 0)", "rgba(96, 191, 96, 0)", +"hwb(120 37.5% 25% / 0)", "rgba(96, 191, 96, 0)", +"hwb(120deg 37.5% 25% / 0.2)", "rgba(96, 191, 96, 0.2)", +"hwb(120 37.5% 25% / 0.2)", "rgba(96, 191, 96, 0.2)", +"hwb(120deg 37.5% 25% / 1)", "rgb(96, 191, 96)", +"hwb(120 37.5% 25% / 1)", "rgb(96, 191, 96)", +"hwb(120deg 37.5% 37.5%)", "rgb(96, 159, 96)", +"hwb(120 37.5% 37.5%)", "rgb(96, 159, 96)", +"hwb(120deg 37.5% 37.5% / 0)", "rgba(96, 159, 96, 0)", +"hwb(120 37.5% 37.5% / 0)", "rgba(96, 159, 96, 0)", +"hwb(120deg 37.5% 37.5% / 0.2)", "rgba(96, 159, 96, 0.2)", +"hwb(120 37.5% 37.5% / 0.2)", "rgba(96, 159, 96, 0.2)", +"hwb(120deg 37.5% 37.5% / 1)", "rgb(96, 159, 96)", +"hwb(120 37.5% 37.5% / 1)", "rgb(96, 159, 96)", +"hwb(120deg 37.5% 50%)", "rgb(96, 128, 96)", +"hwb(120 37.5% 50%)", "rgb(96, 128, 96)", +"hwb(120deg 37.5% 50% / 0)", "rgba(96, 128, 96, 0)", +"hwb(120 37.5% 50% / 0)", "rgba(96, 128, 96, 0)", +"hwb(120deg 37.5% 50% / 0.2)", "rgba(96, 128, 96, 0.2)", +"hwb(120 37.5% 50% / 0.2)", "rgba(96, 128, 96, 0.2)", +"hwb(120deg 37.5% 50% / 1)", "rgb(96, 128, 96)", +"hwb(120 37.5% 50% / 1)", "rgb(96, 128, 96)", +"hwb(120deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(120 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(120deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(120 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(120deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(120 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(120deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(120 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(120deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(120 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(120deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(120 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(120deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(120 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(120deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(120 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(120deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(120 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(120deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(120 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(120deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(120 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(120deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(120 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(120deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(120 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(120deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(120 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(120deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(120 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(120deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(120 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(120deg 50% 0%)", "rgb(128, 255, 128)", +"hwb(120 50% 0%)", "rgb(128, 255, 128)", +"hwb(120deg 50% 0% / 0)", "rgba(128, 255, 128, 0)", +"hwb(120 50% 0% / 0)", "rgba(128, 255, 128, 0)", +"hwb(120deg 50% 0% / 0.2)", "rgba(128, 255, 128, 0.2)", +"hwb(120 50% 0% / 0.2)", "rgba(128, 255, 128, 0.2)", +"hwb(120deg 50% 0% / 1)", "rgb(128, 255, 128)", +"hwb(120 50% 0% / 1)", "rgb(128, 255, 128)", +"hwb(120deg 50% 12.5%)", "rgb(128, 223, 128)", +"hwb(120 50% 12.5%)", "rgb(128, 223, 128)", +"hwb(120deg 50% 12.5% / 0)", "rgba(128, 223, 128, 0)", +"hwb(120 50% 12.5% / 0)", "rgba(128, 223, 128, 0)", +"hwb(120deg 50% 12.5% / 0.2)", "rgba(128, 223, 128, 0.2)", +"hwb(120 50% 12.5% / 0.2)", "rgba(128, 223, 128, 0.2)", +"hwb(120deg 50% 12.5% / 1)", "rgb(128, 223, 128)", +"hwb(120 50% 12.5% / 1)", "rgb(128, 223, 128)", +"hwb(120deg 50% 25%)", "rgb(128, 191, 128)", +"hwb(120 50% 25%)", "rgb(128, 191, 128)", +"hwb(120deg 50% 25% / 0)", "rgba(128, 191, 128, 0)", +"hwb(120 50% 25% / 0)", "rgba(128, 191, 128, 0)", +"hwb(120deg 50% 25% / 0.2)", "rgba(128, 191, 128, 0.2)", +"hwb(120 50% 25% / 0.2)", "rgba(128, 191, 128, 0.2)", +"hwb(120deg 50% 25% / 1)", "rgb(128, 191, 128)", +"hwb(120 50% 25% / 1)", "rgb(128, 191, 128)", +"hwb(120deg 50% 37.5%)", "rgb(128, 159, 128)", +"hwb(120 50% 37.5%)", "rgb(128, 159, 128)", +"hwb(120deg 50% 37.5% / 0)", "rgba(128, 159, 128, 0)", +"hwb(120 50% 37.5% / 0)", "rgba(128, 159, 128, 0)", +"hwb(120deg 50% 37.5% / 0.2)", "rgba(128, 159, 128, 0.2)", +"hwb(120 50% 37.5% / 0.2)", "rgba(128, 159, 128, 0.2)", +"hwb(120deg 50% 37.5% / 1)", "rgb(128, 159, 128)", +"hwb(120 50% 37.5% / 1)", "rgb(128, 159, 128)", +"hwb(120deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(120 50% 50%)", "rgb(128, 128, 128)", +"hwb(120deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(120 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(120deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(120 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(120deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(120 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(120deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(120 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(120deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(120 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(120deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(120 50% 75%)", "rgb(102, 102, 102)", +"hwb(120deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(120 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(120deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(120 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(120deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(120 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(120deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(120 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(120deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(120 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(120deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(120 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(120deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(120 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(120deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(120 50% 100%)", "rgb(85, 85, 85)", +"hwb(120deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(120 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(120deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(120 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(120deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(120 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(120deg 62.5% 0%)", "rgb(159, 255, 159)", +"hwb(120 62.5% 0%)", "rgb(159, 255, 159)", +"hwb(120deg 62.5% 0% / 0)", "rgba(159, 255, 159, 0)", +"hwb(120 62.5% 0% / 0)", "rgba(159, 255, 159, 0)", +"hwb(120deg 62.5% 0% / 0.2)", "rgba(159, 255, 159, 0.2)", +"hwb(120 62.5% 0% / 0.2)", "rgba(159, 255, 159, 0.2)", +"hwb(120deg 62.5% 0% / 1)", "rgb(159, 255, 159)", +"hwb(120 62.5% 0% / 1)", "rgb(159, 255, 159)", +"hwb(120deg 62.5% 12.5%)", "rgb(159, 223, 159)", +"hwb(120 62.5% 12.5%)", "rgb(159, 223, 159)", +"hwb(120deg 62.5% 12.5% / 0)", "rgba(159, 223, 159, 0)", +"hwb(120 62.5% 12.5% / 0)", "rgba(159, 223, 159, 0)", +"hwb(120deg 62.5% 12.5% / 0.2)", "rgba(159, 223, 159, 0.2)", +"hwb(120 62.5% 12.5% / 0.2)", "rgba(159, 223, 159, 0.2)", +"hwb(120deg 62.5% 12.5% / 1)", "rgb(159, 223, 159)", +"hwb(120 62.5% 12.5% / 1)", "rgb(159, 223, 159)", +"hwb(120deg 62.5% 25%)", "rgb(159, 191, 159)", +"hwb(120 62.5% 25%)", "rgb(159, 191, 159)", +"hwb(120deg 62.5% 25% / 0)", "rgba(159, 191, 159, 0)", +"hwb(120 62.5% 25% / 0)", "rgba(159, 191, 159, 0)", +"hwb(120deg 62.5% 25% / 0.2)", "rgba(159, 191, 159, 0.2)", +"hwb(120 62.5% 25% / 0.2)", "rgba(159, 191, 159, 0.2)", +"hwb(120deg 62.5% 25% / 1)", "rgb(159, 191, 159)", +"hwb(120 62.5% 25% / 1)", "rgb(159, 191, 159)", +"hwb(120deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(120 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(120deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(120 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(120deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(120 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(120deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(120 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(120deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(120 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(120deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(120 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(120deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(120 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(120deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(120 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(120deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(120 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(120deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(120 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(120deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(120 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(120deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(120 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(120deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(120 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(120deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(120 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(120deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(120 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(120deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(120 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(120deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(120 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(120deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(120 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(120deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(120 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(120deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(120 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(120deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(120 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(120deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(120 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(120deg 75% 0%)", "rgb(191, 255, 191)", +"hwb(120 75% 0%)", "rgb(191, 255, 191)", +"hwb(120deg 75% 0% / 0)", "rgba(191, 255, 191, 0)", +"hwb(120 75% 0% / 0)", "rgba(191, 255, 191, 0)", +"hwb(120deg 75% 0% / 0.2)", "rgba(191, 255, 191, 0.2)", +"hwb(120 75% 0% / 0.2)", "rgba(191, 255, 191, 0.2)", +"hwb(120deg 75% 0% / 1)", "rgb(191, 255, 191)", +"hwb(120 75% 0% / 1)", "rgb(191, 255, 191)", +"hwb(120deg 75% 12.5%)", "rgb(191, 223, 191)", +"hwb(120 75% 12.5%)", "rgb(191, 223, 191)", +"hwb(120deg 75% 12.5% / 0)", "rgba(191, 223, 191, 0)", +"hwb(120 75% 12.5% / 0)", "rgba(191, 223, 191, 0)", +"hwb(120deg 75% 12.5% / 0.2)", "rgba(191, 223, 191, 0.2)", +"hwb(120 75% 12.5% / 0.2)", "rgba(191, 223, 191, 0.2)", +"hwb(120deg 75% 12.5% / 1)", "rgb(191, 223, 191)", +"hwb(120 75% 12.5% / 1)", "rgb(191, 223, 191)", +"hwb(120deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(120 75% 25%)", "rgb(191, 191, 191)", +"hwb(120deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(120 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(120deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(120 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(120deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(120 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(120deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(120 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(120deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(120 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(120deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(120 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(120deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(120 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(120deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(120 75% 50%)", "rgb(153, 153, 153)", +"hwb(120deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(120 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(120deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(120 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(120deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(120 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(120deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(120 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(120deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(120 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(120deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(120 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(120deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(120 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(120deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(120 75% 75%)", "rgb(128, 128, 128)", +"hwb(120deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(120 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(120deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(120 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(120deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(120 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(120deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(120 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(120deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(120 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(120deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(120 75% 100%)", "rgb(109, 109, 109)", +"hwb(120deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(120 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(120deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(120 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(120deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(120 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(120deg 87.5% 0%)", "rgb(223, 255, 223)", +"hwb(120 87.5% 0%)", "rgb(223, 255, 223)", +"hwb(120deg 87.5% 0% / 0)", "rgba(223, 255, 223, 0)", +"hwb(120 87.5% 0% / 0)", "rgba(223, 255, 223, 0)", +"hwb(120deg 87.5% 0% / 0.2)", "rgba(223, 255, 223, 0.2)", +"hwb(120 87.5% 0% / 0.2)", "rgba(223, 255, 223, 0.2)", +"hwb(120deg 87.5% 0% / 1)", "rgb(223, 255, 223)", +"hwb(120 87.5% 0% / 1)", "rgb(223, 255, 223)", +"hwb(120deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(120 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(120deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(120 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(120deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(120 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(120deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(120 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(120deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(120 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(120deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(120 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(120deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(120 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(120deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(120 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(120deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(120 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(120deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(120 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(120deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(120 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(120deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(120 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(120deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(120 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(120deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(120 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(120deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(120 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(120deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(120 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(120deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(120 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(120deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(120 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(120deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(120 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(120deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(120 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(120deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(120 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(120deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(120 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(120deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(120 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(120deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(120 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(120deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(120 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(120deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(120 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(120deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(120 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(120deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(120 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(120deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(120 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(120deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(120 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(120deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(120 100% 0%)", "rgb(255, 255, 255)", +"hwb(120deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(120 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(120deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(120 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(120deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(120 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(120deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(120 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(120deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(120 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(120deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(120 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(120deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(120 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(120deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(120 100% 25%)", "rgb(204, 204, 204)", +"hwb(120deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(120 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(120deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(120 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(120deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(120 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(120deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(120 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(120deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(120 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(120deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(120 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(120deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(120 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(120deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(120 100% 50%)", "rgb(170, 170, 170)", +"hwb(120deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(120 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(120deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(120 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(120deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(120 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(120deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(120 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(120deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(120 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(120deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(120 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(120deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(120 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(120deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(120 100% 75%)", "rgb(146, 146, 146)", +"hwb(120deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(120 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(120deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(120 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(120deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(120 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(120deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(120 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(120deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(120 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(120deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(120 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(120deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(120 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(120deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(120 100% 100%)", "rgb(128, 128, 128)", +"hwb(120deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(120deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(120deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(120 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(180deg 0% 0%)", "rgb(0, 255, 255)", +"hwb(180 0% 0%)", "rgb(0, 255, 255)", +"hwb(180deg 0% 0% / 0)", "rgba(0, 255, 255, 0)", +"hwb(180 0% 0% / 0)", "rgba(0, 255, 255, 0)", +"hwb(180deg 0% 0% / 0.2)", "rgba(0, 255, 255, 0.2)", +"hwb(180 0% 0% / 0.2)", "rgba(0, 255, 255, 0.2)", +"hwb(180deg 0% 0% / 1)", "rgb(0, 255, 255)", +"hwb(180 0% 0% / 1)", "rgb(0, 255, 255)", +"hwb(180deg 0% 12.5%)", "rgb(0, 223, 223)", +"hwb(180 0% 12.5%)", "rgb(0, 223, 223)", +"hwb(180deg 0% 12.5% / 0)", "rgba(0, 223, 223, 0)", +"hwb(180 0% 12.5% / 0)", "rgba(0, 223, 223, 0)", +"hwb(180deg 0% 12.5% / 0.2)", "rgba(0, 223, 223, 0.2)", +"hwb(180 0% 12.5% / 0.2)", "rgba(0, 223, 223, 0.2)", +"hwb(180deg 0% 12.5% / 1)", "rgb(0, 223, 223)", +"hwb(180 0% 12.5% / 1)", "rgb(0, 223, 223)", +"hwb(180deg 0% 25%)", "rgb(0, 191, 191)", +"hwb(180 0% 25%)", "rgb(0, 191, 191)", +"hwb(180deg 0% 25% / 0)", "rgba(0, 191, 191, 0)", +"hwb(180 0% 25% / 0)", "rgba(0, 191, 191, 0)", +"hwb(180deg 0% 25% / 0.2)", "rgba(0, 191, 191, 0.2)", +"hwb(180 0% 25% / 0.2)", "rgba(0, 191, 191, 0.2)", +"hwb(180deg 0% 25% / 1)", "rgb(0, 191, 191)", +"hwb(180 0% 25% / 1)", "rgb(0, 191, 191)", +"hwb(180deg 0% 37.5%)", "rgb(0, 159, 159)", +"hwb(180 0% 37.5%)", "rgb(0, 159, 159)", +"hwb(180deg 0% 37.5% / 0)", "rgba(0, 159, 159, 0)", +"hwb(180 0% 37.5% / 0)", "rgba(0, 159, 159, 0)", +"hwb(180deg 0% 37.5% / 0.2)", "rgba(0, 159, 159, 0.2)", +"hwb(180 0% 37.5% / 0.2)", "rgba(0, 159, 159, 0.2)", +"hwb(180deg 0% 37.5% / 1)", "rgb(0, 159, 159)", +"hwb(180 0% 37.5% / 1)", "rgb(0, 159, 159)", +"hwb(180deg 0% 50%)", "rgb(0, 128, 128)", +"hwb(180 0% 50%)", "rgb(0, 128, 128)", +"hwb(180deg 0% 50% / 0)", "rgba(0, 128, 128, 0)", +"hwb(180 0% 50% / 0)", "rgba(0, 128, 128, 0)", +"hwb(180deg 0% 50% / 0.2)", "rgba(0, 128, 128, 0.2)", +"hwb(180 0% 50% / 0.2)", "rgba(0, 128, 128, 0.2)", +"hwb(180deg 0% 50% / 1)", "rgb(0, 128, 128)", +"hwb(180 0% 50% / 1)", "rgb(0, 128, 128)", +"hwb(180deg 0% 62.5%)", "rgb(0, 96, 96)", +"hwb(180 0% 62.5%)", "rgb(0, 96, 96)", +"hwb(180deg 0% 62.5% / 0)", "rgba(0, 96, 96, 0)", +"hwb(180 0% 62.5% / 0)", "rgba(0, 96, 96, 0)", +"hwb(180deg 0% 62.5% / 0.2)", "rgba(0, 96, 96, 0.2)", +"hwb(180 0% 62.5% / 0.2)", "rgba(0, 96, 96, 0.2)", +"hwb(180deg 0% 62.5% / 1)", "rgb(0, 96, 96)", +"hwb(180 0% 62.5% / 1)", "rgb(0, 96, 96)", +"hwb(180deg 0% 75%)", "rgb(0, 64, 64)", +"hwb(180 0% 75%)", "rgb(0, 64, 64)", +"hwb(180deg 0% 75% / 0)", "rgba(0, 64, 64, 0)", +"hwb(180 0% 75% / 0)", "rgba(0, 64, 64, 0)", +"hwb(180deg 0% 75% / 0.2)", "rgba(0, 64, 64, 0.2)", +"hwb(180 0% 75% / 0.2)", "rgba(0, 64, 64, 0.2)", +"hwb(180deg 0% 75% / 1)", "rgb(0, 64, 64)", +"hwb(180 0% 75% / 1)", "rgb(0, 64, 64)", +"hwb(180deg 0% 87.5%)", "rgb(0, 32, 32)", +"hwb(180 0% 87.5%)", "rgb(0, 32, 32)", +"hwb(180deg 0% 87.5% / 0)", "rgba(0, 32, 32, 0)", +"hwb(180 0% 87.5% / 0)", "rgba(0, 32, 32, 0)", +"hwb(180deg 0% 87.5% / 0.2)", "rgba(0, 32, 32, 0.2)", +"hwb(180 0% 87.5% / 0.2)", "rgba(0, 32, 32, 0.2)", +"hwb(180deg 0% 87.5% / 1)", "rgb(0, 32, 32)", +"hwb(180 0% 87.5% / 1)", "rgb(0, 32, 32)", +"hwb(180deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(180 0% 100%)", "rgb(0, 0, 0)", +"hwb(180deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(180 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(180deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(180 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(180deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(180 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(180deg 12.5% 0%)", "rgb(32, 255, 255)", +"hwb(180 12.5% 0%)", "rgb(32, 255, 255)", +"hwb(180deg 12.5% 0% / 0)", "rgba(32, 255, 255, 0)", +"hwb(180 12.5% 0% / 0)", "rgba(32, 255, 255, 0)", +"hwb(180deg 12.5% 0% / 0.2)", "rgba(32, 255, 255, 0.2)", +"hwb(180 12.5% 0% / 0.2)", "rgba(32, 255, 255, 0.2)", +"hwb(180deg 12.5% 0% / 1)", "rgb(32, 255, 255)", +"hwb(180 12.5% 0% / 1)", "rgb(32, 255, 255)", +"hwb(180deg 12.5% 12.5%)", "rgb(32, 223, 223)", +"hwb(180 12.5% 12.5%)", "rgb(32, 223, 223)", +"hwb(180deg 12.5% 12.5% / 0)", "rgba(32, 223, 223, 0)", +"hwb(180 12.5% 12.5% / 0)", "rgba(32, 223, 223, 0)", +"hwb(180deg 12.5% 12.5% / 0.2)", "rgba(32, 223, 223, 0.2)", +"hwb(180 12.5% 12.5% / 0.2)", "rgba(32, 223, 223, 0.2)", +"hwb(180deg 12.5% 12.5% / 1)", "rgb(32, 223, 223)", +"hwb(180 12.5% 12.5% / 1)", "rgb(32, 223, 223)", +"hwb(180deg 12.5% 25%)", "rgb(32, 191, 191)", +"hwb(180 12.5% 25%)", "rgb(32, 191, 191)", +"hwb(180deg 12.5% 25% / 0)", "rgba(32, 191, 191, 0)", +"hwb(180 12.5% 25% / 0)", "rgba(32, 191, 191, 0)", +"hwb(180deg 12.5% 25% / 0.2)", "rgba(32, 191, 191, 0.2)", +"hwb(180 12.5% 25% / 0.2)", "rgba(32, 191, 191, 0.2)", +"hwb(180deg 12.5% 25% / 1)", "rgb(32, 191, 191)", +"hwb(180 12.5% 25% / 1)", "rgb(32, 191, 191)", +"hwb(180deg 12.5% 37.5%)", "rgb(32, 159, 159)", +"hwb(180 12.5% 37.5%)", "rgb(32, 159, 159)", +"hwb(180deg 12.5% 37.5% / 0)", "rgba(32, 159, 159, 0)", +"hwb(180 12.5% 37.5% / 0)", "rgba(32, 159, 159, 0)", +"hwb(180deg 12.5% 37.5% / 0.2)", "rgba(32, 159, 159, 0.2)", +"hwb(180 12.5% 37.5% / 0.2)", "rgba(32, 159, 159, 0.2)", +"hwb(180deg 12.5% 37.5% / 1)", "rgb(32, 159, 159)", +"hwb(180 12.5% 37.5% / 1)", "rgb(32, 159, 159)", +"hwb(180deg 12.5% 50%)", "rgb(32, 128, 128)", +"hwb(180 12.5% 50%)", "rgb(32, 128, 128)", +"hwb(180deg 12.5% 50% / 0)", "rgba(32, 128, 128, 0)", +"hwb(180 12.5% 50% / 0)", "rgba(32, 128, 128, 0)", +"hwb(180deg 12.5% 50% / 0.2)", "rgba(32, 128, 128, 0.2)", +"hwb(180 12.5% 50% / 0.2)", "rgba(32, 128, 128, 0.2)", +"hwb(180deg 12.5% 50% / 1)", "rgb(32, 128, 128)", +"hwb(180 12.5% 50% / 1)", "rgb(32, 128, 128)", +"hwb(180deg 12.5% 62.5%)", "rgb(32, 96, 96)", +"hwb(180 12.5% 62.5%)", "rgb(32, 96, 96)", +"hwb(180deg 12.5% 62.5% / 0)", "rgba(32, 96, 96, 0)", +"hwb(180 12.5% 62.5% / 0)", "rgba(32, 96, 96, 0)", +"hwb(180deg 12.5% 62.5% / 0.2)", "rgba(32, 96, 96, 0.2)", +"hwb(180 12.5% 62.5% / 0.2)", "rgba(32, 96, 96, 0.2)", +"hwb(180deg 12.5% 62.5% / 1)", "rgb(32, 96, 96)", +"hwb(180 12.5% 62.5% / 1)", "rgb(32, 96, 96)", +"hwb(180deg 12.5% 75%)", "rgb(32, 64, 64)", +"hwb(180 12.5% 75%)", "rgb(32, 64, 64)", +"hwb(180deg 12.5% 75% / 0)", "rgba(32, 64, 64, 0)", +"hwb(180 12.5% 75% / 0)", "rgba(32, 64, 64, 0)", +"hwb(180deg 12.5% 75% / 0.2)", "rgba(32, 64, 64, 0.2)", +"hwb(180 12.5% 75% / 0.2)", "rgba(32, 64, 64, 0.2)", +"hwb(180deg 12.5% 75% / 1)", "rgb(32, 64, 64)", +"hwb(180 12.5% 75% / 1)", "rgb(32, 64, 64)", +"hwb(180deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(180 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(180deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(180 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(180deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(180 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(180deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(180 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(180deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(180 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(180deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(180 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(180deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(180 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(180deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(180 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(180deg 25% 0%)", "rgb(64, 255, 255)", +"hwb(180 25% 0%)", "rgb(64, 255, 255)", +"hwb(180deg 25% 0% / 0)", "rgba(64, 255, 255, 0)", +"hwb(180 25% 0% / 0)", "rgba(64, 255, 255, 0)", +"hwb(180deg 25% 0% / 0.2)", "rgba(64, 255, 255, 0.2)", +"hwb(180 25% 0% / 0.2)", "rgba(64, 255, 255, 0.2)", +"hwb(180deg 25% 0% / 1)", "rgb(64, 255, 255)", +"hwb(180 25% 0% / 1)", "rgb(64, 255, 255)", +"hwb(180deg 25% 12.5%)", "rgb(64, 223, 223)", +"hwb(180 25% 12.5%)", "rgb(64, 223, 223)", +"hwb(180deg 25% 12.5% / 0)", "rgba(64, 223, 223, 0)", +"hwb(180 25% 12.5% / 0)", "rgba(64, 223, 223, 0)", +"hwb(180deg 25% 12.5% / 0.2)", "rgba(64, 223, 223, 0.2)", +"hwb(180 25% 12.5% / 0.2)", "rgba(64, 223, 223, 0.2)", +"hwb(180deg 25% 12.5% / 1)", "rgb(64, 223, 223)", +"hwb(180 25% 12.5% / 1)", "rgb(64, 223, 223)", +"hwb(180deg 25% 25%)", "rgb(64, 191, 191)", +"hwb(180 25% 25%)", "rgb(64, 191, 191)", +"hwb(180deg 25% 25% / 0)", "rgba(64, 191, 191, 0)", +"hwb(180 25% 25% / 0)", "rgba(64, 191, 191, 0)", +"hwb(180deg 25% 25% / 0.2)", "rgba(64, 191, 191, 0.2)", +"hwb(180 25% 25% / 0.2)", "rgba(64, 191, 191, 0.2)", +"hwb(180deg 25% 25% / 1)", "rgb(64, 191, 191)", +"hwb(180 25% 25% / 1)", "rgb(64, 191, 191)", +"hwb(180deg 25% 37.5%)", "rgb(64, 159, 159)", +"hwb(180 25% 37.5%)", "rgb(64, 159, 159)", +"hwb(180deg 25% 37.5% / 0)", "rgba(64, 159, 159, 0)", +"hwb(180 25% 37.5% / 0)", "rgba(64, 159, 159, 0)", +"hwb(180deg 25% 37.5% / 0.2)", "rgba(64, 159, 159, 0.2)", +"hwb(180 25% 37.5% / 0.2)", "rgba(64, 159, 159, 0.2)", +"hwb(180deg 25% 37.5% / 1)", "rgb(64, 159, 159)", +"hwb(180 25% 37.5% / 1)", "rgb(64, 159, 159)", +"hwb(180deg 25% 50%)", "rgb(64, 128, 128)", +"hwb(180 25% 50%)", "rgb(64, 128, 128)", +"hwb(180deg 25% 50% / 0)", "rgba(64, 128, 128, 0)", +"hwb(180 25% 50% / 0)", "rgba(64, 128, 128, 0)", +"hwb(180deg 25% 50% / 0.2)", "rgba(64, 128, 128, 0.2)", +"hwb(180 25% 50% / 0.2)", "rgba(64, 128, 128, 0.2)", +"hwb(180deg 25% 50% / 1)", "rgb(64, 128, 128)", +"hwb(180 25% 50% / 1)", "rgb(64, 128, 128)", +"hwb(180deg 25% 62.5%)", "rgb(64, 96, 96)", +"hwb(180 25% 62.5%)", "rgb(64, 96, 96)", +"hwb(180deg 25% 62.5% / 0)", "rgba(64, 96, 96, 0)", +"hwb(180 25% 62.5% / 0)", "rgba(64, 96, 96, 0)", +"hwb(180deg 25% 62.5% / 0.2)", "rgba(64, 96, 96, 0.2)", +"hwb(180 25% 62.5% / 0.2)", "rgba(64, 96, 96, 0.2)", +"hwb(180deg 25% 62.5% / 1)", "rgb(64, 96, 96)", +"hwb(180 25% 62.5% / 1)", "rgb(64, 96, 96)", +"hwb(180deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(180 25% 75%)", "rgb(64, 64, 64)", +"hwb(180deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(180 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(180deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(180 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(180deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(180 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(180deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(180 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(180deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(180 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(180deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(180 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(180deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(180 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(180deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(180 25% 100%)", "rgb(51, 51, 51)", +"hwb(180deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(180 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(180deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(180 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(180deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(180 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(180deg 37.5% 0%)", "rgb(96, 255, 255)", +"hwb(180 37.5% 0%)", "rgb(96, 255, 255)", +"hwb(180deg 37.5% 0% / 0)", "rgba(96, 255, 255, 0)", +"hwb(180 37.5% 0% / 0)", "rgba(96, 255, 255, 0)", +"hwb(180deg 37.5% 0% / 0.2)", "rgba(96, 255, 255, 0.2)", +"hwb(180 37.5% 0% / 0.2)", "rgba(96, 255, 255, 0.2)", +"hwb(180deg 37.5% 0% / 1)", "rgb(96, 255, 255)", +"hwb(180 37.5% 0% / 1)", "rgb(96, 255, 255)", +"hwb(180deg 37.5% 12.5%)", "rgb(96, 223, 223)", +"hwb(180 37.5% 12.5%)", "rgb(96, 223, 223)", +"hwb(180deg 37.5% 12.5% / 0)", "rgba(96, 223, 223, 0)", +"hwb(180 37.5% 12.5% / 0)", "rgba(96, 223, 223, 0)", +"hwb(180deg 37.5% 12.5% / 0.2)", "rgba(96, 223, 223, 0.2)", +"hwb(180 37.5% 12.5% / 0.2)", "rgba(96, 223, 223, 0.2)", +"hwb(180deg 37.5% 12.5% / 1)", "rgb(96, 223, 223)", +"hwb(180 37.5% 12.5% / 1)", "rgb(96, 223, 223)", +"hwb(180deg 37.5% 25%)", "rgb(96, 191, 191)", +"hwb(180 37.5% 25%)", "rgb(96, 191, 191)", +"hwb(180deg 37.5% 25% / 0)", "rgba(96, 191, 191, 0)", +"hwb(180 37.5% 25% / 0)", "rgba(96, 191, 191, 0)", +"hwb(180deg 37.5% 25% / 0.2)", "rgba(96, 191, 191, 0.2)", +"hwb(180 37.5% 25% / 0.2)", "rgba(96, 191, 191, 0.2)", +"hwb(180deg 37.5% 25% / 1)", "rgb(96, 191, 191)", +"hwb(180 37.5% 25% / 1)", "rgb(96, 191, 191)", +"hwb(180deg 37.5% 37.5%)", "rgb(96, 159, 159)", +"hwb(180 37.5% 37.5%)", "rgb(96, 159, 159)", +"hwb(180deg 37.5% 37.5% / 0)", "rgba(96, 159, 159, 0)", +"hwb(180 37.5% 37.5% / 0)", "rgba(96, 159, 159, 0)", +"hwb(180deg 37.5% 37.5% / 0.2)", "rgba(96, 159, 159, 0.2)", +"hwb(180 37.5% 37.5% / 0.2)", "rgba(96, 159, 159, 0.2)", +"hwb(180deg 37.5% 37.5% / 1)", "rgb(96, 159, 159)", +"hwb(180 37.5% 37.5% / 1)", "rgb(96, 159, 159)", +"hwb(180deg 37.5% 50%)", "rgb(96, 128, 128)", +"hwb(180 37.5% 50%)", "rgb(96, 128, 128)", +"hwb(180deg 37.5% 50% / 0)", "rgba(96, 128, 128, 0)", +"hwb(180 37.5% 50% / 0)", "rgba(96, 128, 128, 0)", +"hwb(180deg 37.5% 50% / 0.2)", "rgba(96, 128, 128, 0.2)", +"hwb(180 37.5% 50% / 0.2)", "rgba(96, 128, 128, 0.2)", +"hwb(180deg 37.5% 50% / 1)", "rgb(96, 128, 128)", +"hwb(180 37.5% 50% / 1)", "rgb(96, 128, 128)", +"hwb(180deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(180 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(180deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(180 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(180deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(180 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(180deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(180 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(180deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(180 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(180deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(180 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(180deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(180 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(180deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(180 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(180deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(180 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(180deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(180 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(180deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(180 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(180deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(180 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(180deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(180 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(180deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(180 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(180deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(180 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(180deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(180 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(180deg 50% 0%)", "rgb(128, 255, 255)", +"hwb(180 50% 0%)", "rgb(128, 255, 255)", +"hwb(180deg 50% 0% / 0)", "rgba(128, 255, 255, 0)", +"hwb(180 50% 0% / 0)", "rgba(128, 255, 255, 0)", +"hwb(180deg 50% 0% / 0.2)", "rgba(128, 255, 255, 0.2)", +"hwb(180 50% 0% / 0.2)", "rgba(128, 255, 255, 0.2)", +"hwb(180deg 50% 0% / 1)", "rgb(128, 255, 255)", +"hwb(180 50% 0% / 1)", "rgb(128, 255, 255)", +"hwb(180deg 50% 12.5%)", "rgb(128, 223, 223)", +"hwb(180 50% 12.5%)", "rgb(128, 223, 223)", +"hwb(180deg 50% 12.5% / 0)", "rgba(128, 223, 223, 0)", +"hwb(180 50% 12.5% / 0)", "rgba(128, 223, 223, 0)", +"hwb(180deg 50% 12.5% / 0.2)", "rgba(128, 223, 223, 0.2)", +"hwb(180 50% 12.5% / 0.2)", "rgba(128, 223, 223, 0.2)", +"hwb(180deg 50% 12.5% / 1)", "rgb(128, 223, 223)", +"hwb(180 50% 12.5% / 1)", "rgb(128, 223, 223)", +"hwb(180deg 50% 25%)", "rgb(128, 191, 191)", +"hwb(180 50% 25%)", "rgb(128, 191, 191)", +"hwb(180deg 50% 25% / 0)", "rgba(128, 191, 191, 0)", +"hwb(180 50% 25% / 0)", "rgba(128, 191, 191, 0)", +"hwb(180deg 50% 25% / 0.2)", "rgba(128, 191, 191, 0.2)", +"hwb(180 50% 25% / 0.2)", "rgba(128, 191, 191, 0.2)", +"hwb(180deg 50% 25% / 1)", "rgb(128, 191, 191)", +"hwb(180 50% 25% / 1)", "rgb(128, 191, 191)", +"hwb(180deg 50% 37.5%)", "rgb(128, 159, 159)", +"hwb(180 50% 37.5%)", "rgb(128, 159, 159)", +"hwb(180deg 50% 37.5% / 0)", "rgba(128, 159, 159, 0)", +"hwb(180 50% 37.5% / 0)", "rgba(128, 159, 159, 0)", +"hwb(180deg 50% 37.5% / 0.2)", "rgba(128, 159, 159, 0.2)", +"hwb(180 50% 37.5% / 0.2)", "rgba(128, 159, 159, 0.2)", +"hwb(180deg 50% 37.5% / 1)", "rgb(128, 159, 159)", +"hwb(180 50% 37.5% / 1)", "rgb(128, 159, 159)", +"hwb(180deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(180 50% 50%)", "rgb(128, 128, 128)", +"hwb(180deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(180 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(180deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(180 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(180deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(180 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(180deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(180 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(180deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(180 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(180deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(180 50% 75%)", "rgb(102, 102, 102)", +"hwb(180deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(180 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(180deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(180 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(180deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(180 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(180deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(180 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(180deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(180 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(180deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(180 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(180deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(180 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(180deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(180 50% 100%)", "rgb(85, 85, 85)", +"hwb(180deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(180 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(180deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(180 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(180deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(180 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(180deg 62.5% 0%)", "rgb(159, 255, 255)", +"hwb(180 62.5% 0%)", "rgb(159, 255, 255)", +"hwb(180deg 62.5% 0% / 0)", "rgba(159, 255, 255, 0)", +"hwb(180 62.5% 0% / 0)", "rgba(159, 255, 255, 0)", +"hwb(180deg 62.5% 0% / 0.2)", "rgba(159, 255, 255, 0.2)", +"hwb(180 62.5% 0% / 0.2)", "rgba(159, 255, 255, 0.2)", +"hwb(180deg 62.5% 0% / 1)", "rgb(159, 255, 255)", +"hwb(180 62.5% 0% / 1)", "rgb(159, 255, 255)", +"hwb(180deg 62.5% 12.5%)", "rgb(159, 223, 223)", +"hwb(180 62.5% 12.5%)", "rgb(159, 223, 223)", +"hwb(180deg 62.5% 12.5% / 0)", "rgba(159, 223, 223, 0)", +"hwb(180 62.5% 12.5% / 0)", "rgba(159, 223, 223, 0)", +"hwb(180deg 62.5% 12.5% / 0.2)", "rgba(159, 223, 223, 0.2)", +"hwb(180 62.5% 12.5% / 0.2)", "rgba(159, 223, 223, 0.2)", +"hwb(180deg 62.5% 12.5% / 1)", "rgb(159, 223, 223)", +"hwb(180 62.5% 12.5% / 1)", "rgb(159, 223, 223)", +"hwb(180deg 62.5% 25%)", "rgb(159, 191, 191)", +"hwb(180 62.5% 25%)", "rgb(159, 191, 191)", +"hwb(180deg 62.5% 25% / 0)", "rgba(159, 191, 191, 0)", +"hwb(180 62.5% 25% / 0)", "rgba(159, 191, 191, 0)", +"hwb(180deg 62.5% 25% / 0.2)", "rgba(159, 191, 191, 0.2)", +"hwb(180 62.5% 25% / 0.2)", "rgba(159, 191, 191, 0.2)", +"hwb(180deg 62.5% 25% / 1)", "rgb(159, 191, 191)", +"hwb(180 62.5% 25% / 1)", "rgb(159, 191, 191)", +"hwb(180deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(180 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(180deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(180 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(180deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(180 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(180deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(180 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(180deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(180 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(180deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(180 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(180deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(180 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(180deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(180 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(180deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(180 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(180deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(180 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(180deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(180 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(180deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(180 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(180deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(180 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(180deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(180 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(180deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(180 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(180deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(180 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(180deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(180 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(180deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(180 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(180deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(180 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(180deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(180 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(180deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(180 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(180deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(180 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(180deg 75% 0%)", "rgb(191, 255, 255)", +"hwb(180 75% 0%)", "rgb(191, 255, 255)", +"hwb(180deg 75% 0% / 0)", "rgba(191, 255, 255, 0)", +"hwb(180 75% 0% / 0)", "rgba(191, 255, 255, 0)", +"hwb(180deg 75% 0% / 0.2)", "rgba(191, 255, 255, 0.2)", +"hwb(180 75% 0% / 0.2)", "rgba(191, 255, 255, 0.2)", +"hwb(180deg 75% 0% / 1)", "rgb(191, 255, 255)", +"hwb(180 75% 0% / 1)", "rgb(191, 255, 255)", +"hwb(180deg 75% 12.5%)", "rgb(191, 223, 223)", +"hwb(180 75% 12.5%)", "rgb(191, 223, 223)", +"hwb(180deg 75% 12.5% / 0)", "rgba(191, 223, 223, 0)", +"hwb(180 75% 12.5% / 0)", "rgba(191, 223, 223, 0)", +"hwb(180deg 75% 12.5% / 0.2)", "rgba(191, 223, 223, 0.2)", +"hwb(180 75% 12.5% / 0.2)", "rgba(191, 223, 223, 0.2)", +"hwb(180deg 75% 12.5% / 1)", "rgb(191, 223, 223)", +"hwb(180 75% 12.5% / 1)", "rgb(191, 223, 223)", +"hwb(180deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(180 75% 25%)", "rgb(191, 191, 191)", +"hwb(180deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(180 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(180deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(180 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(180deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(180 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(180deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(180 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(180deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(180 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(180deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(180 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(180deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(180 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(180deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(180 75% 50%)", "rgb(153, 153, 153)", +"hwb(180deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(180 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(180deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(180 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(180deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(180 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(180deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(180 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(180deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(180 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(180deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(180 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(180deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(180 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(180deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(180 75% 75%)", "rgb(128, 128, 128)", +"hwb(180deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(180 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(180deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(180 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(180deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(180 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(180deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(180 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(180deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(180 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(180deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(180 75% 100%)", "rgb(109, 109, 109)", +"hwb(180deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(180 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(180deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(180 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(180deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(180 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(180deg 87.5% 0%)", "rgb(223, 255, 255)", +"hwb(180 87.5% 0%)", "rgb(223, 255, 255)", +"hwb(180deg 87.5% 0% / 0)", "rgba(223, 255, 255, 0)", +"hwb(180 87.5% 0% / 0)", "rgba(223, 255, 255, 0)", +"hwb(180deg 87.5% 0% / 0.2)", "rgba(223, 255, 255, 0.2)", +"hwb(180 87.5% 0% / 0.2)", "rgba(223, 255, 255, 0.2)", +"hwb(180deg 87.5% 0% / 1)", "rgb(223, 255, 255)", +"hwb(180 87.5% 0% / 1)", "rgb(223, 255, 255)", +"hwb(180deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(180 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(180deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(180 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(180deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(180 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(180deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(180 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(180deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(180 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(180deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(180 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(180deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(180 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(180deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(180 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(180deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(180 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(180deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(180 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(180deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(180 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(180deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(180 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(180deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(180 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(180deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(180 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(180deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(180 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(180deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(180 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(180deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(180 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(180deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(180 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(180deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(180 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(180deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(180 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(180deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(180 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(180deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(180 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(180deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(180 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(180deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(180 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(180deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(180 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(180deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(180 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(180deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(180 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(180deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(180 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(180deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(180 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(180deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(180 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(180deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(180 100% 0%)", "rgb(255, 255, 255)", +"hwb(180deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(180 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(180deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(180 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(180deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(180 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(180deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(180 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(180deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(180 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(180deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(180 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(180deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(180 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(180deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(180 100% 25%)", "rgb(204, 204, 204)", +"hwb(180deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(180 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(180deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(180 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(180deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(180 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(180deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(180 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(180deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(180 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(180deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(180 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(180deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(180 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(180deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(180 100% 50%)", "rgb(170, 170, 170)", +"hwb(180deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(180 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(180deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(180 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(180deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(180 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(180deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(180 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(180deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(180 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(180deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(180 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(180deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(180 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(180deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(180 100% 75%)", "rgb(146, 146, 146)", +"hwb(180deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(180 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(180deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(180 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(180deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(180 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(180deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(180 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(180deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(180 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(180deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(180 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(180deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(180 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(180deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(180 100% 100%)", "rgb(128, 128, 128)", +"hwb(180deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(180deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(180deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(180 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(210deg 0% 0%)", "rgb(0, 128, 255)", +"hwb(210 0% 0%)", "rgb(0, 128, 255)", +"hwb(210deg 0% 0% / 0)", "rgba(0, 128, 255, 0)", +"hwb(210 0% 0% / 0)", "rgba(0, 128, 255, 0)", +"hwb(210deg 0% 0% / 0.2)", "rgba(0, 128, 255, 0.2)", +"hwb(210 0% 0% / 0.2)", "rgba(0, 128, 255, 0.2)", +"hwb(210deg 0% 0% / 1)", "rgb(0, 128, 255)", +"hwb(210 0% 0% / 1)", "rgb(0, 128, 255)", +"hwb(210deg 0% 12.5%)", "rgb(0, 112, 223)", +"hwb(210 0% 12.5%)", "rgb(0, 112, 223)", +"hwb(210deg 0% 12.5% / 0)", "rgba(0, 112, 223, 0)", +"hwb(210 0% 12.5% / 0)", "rgba(0, 112, 223, 0)", +"hwb(210deg 0% 12.5% / 0.2)", "rgba(0, 112, 223, 0.2)", +"hwb(210 0% 12.5% / 0.2)", "rgba(0, 112, 223, 0.2)", +"hwb(210deg 0% 12.5% / 1)", "rgb(0, 112, 223)", +"hwb(210 0% 12.5% / 1)", "rgb(0, 112, 223)", +"hwb(210deg 0% 25%)", "rgb(0, 96, 191)", +"hwb(210 0% 25%)", "rgb(0, 96, 191)", +"hwb(210deg 0% 25% / 0)", "rgba(0, 96, 191, 0)", +"hwb(210 0% 25% / 0)", "rgba(0, 96, 191, 0)", +"hwb(210deg 0% 25% / 0.2)", "rgba(0, 96, 191, 0.2)", +"hwb(210 0% 25% / 0.2)", "rgba(0, 96, 191, 0.2)", +"hwb(210deg 0% 25% / 1)", "rgb(0, 96, 191)", +"hwb(210 0% 25% / 1)", "rgb(0, 96, 191)", +"hwb(210deg 0% 37.5%)", "rgb(0, 80, 159)", +"hwb(210 0% 37.5%)", "rgb(0, 80, 159)", +"hwb(210deg 0% 37.5% / 0)", "rgba(0, 80, 159, 0)", +"hwb(210 0% 37.5% / 0)", "rgba(0, 80, 159, 0)", +"hwb(210deg 0% 37.5% / 0.2)", "rgba(0, 80, 159, 0.2)", +"hwb(210 0% 37.5% / 0.2)", "rgba(0, 80, 159, 0.2)", +"hwb(210deg 0% 37.5% / 1)", "rgb(0, 80, 159)", +"hwb(210 0% 37.5% / 1)", "rgb(0, 80, 159)", +"hwb(210deg 0% 50%)", "rgb(0, 64, 128)", +"hwb(210 0% 50%)", "rgb(0, 64, 128)", +"hwb(210deg 0% 50% / 0)", "rgba(0, 64, 128, 0)", +"hwb(210 0% 50% / 0)", "rgba(0, 64, 128, 0)", +"hwb(210deg 0% 50% / 0.2)", "rgba(0, 64, 128, 0.2)", +"hwb(210 0% 50% / 0.2)", "rgba(0, 64, 128, 0.2)", +"hwb(210deg 0% 50% / 1)", "rgb(0, 64, 128)", +"hwb(210 0% 50% / 1)", "rgb(0, 64, 128)", +"hwb(210deg 0% 62.5%)", "rgb(0, 48, 96)", +"hwb(210 0% 62.5%)", "rgb(0, 48, 96)", +"hwb(210deg 0% 62.5% / 0)", "rgba(0, 48, 96, 0)", +"hwb(210 0% 62.5% / 0)", "rgba(0, 48, 96, 0)", +"hwb(210deg 0% 62.5% / 0.2)", "rgba(0, 48, 96, 0.2)", +"hwb(210 0% 62.5% / 0.2)", "rgba(0, 48, 96, 0.2)", +"hwb(210deg 0% 62.5% / 1)", "rgb(0, 48, 96)", +"hwb(210 0% 62.5% / 1)", "rgb(0, 48, 96)", +"hwb(210deg 0% 75%)", "rgb(0, 32, 64)", +"hwb(210 0% 75%)", "rgb(0, 32, 64)", +"hwb(210deg 0% 75% / 0)", "rgba(0, 32, 64, 0)", +"hwb(210 0% 75% / 0)", "rgba(0, 32, 64, 0)", +"hwb(210deg 0% 75% / 0.2)", "rgba(0, 32, 64, 0.2)", +"hwb(210 0% 75% / 0.2)", "rgba(0, 32, 64, 0.2)", +"hwb(210deg 0% 75% / 1)", "rgb(0, 32, 64)", +"hwb(210 0% 75% / 1)", "rgb(0, 32, 64)", +"hwb(210deg 0% 87.5%)", "rgb(0, 16, 32)", +"hwb(210 0% 87.5%)", "rgb(0, 16, 32)", +"hwb(210deg 0% 87.5% / 0)", "rgba(0, 16, 32, 0)", +"hwb(210 0% 87.5% / 0)", "rgba(0, 16, 32, 0)", +"hwb(210deg 0% 87.5% / 0.2)", "rgba(0, 16, 32, 0.2)", +"hwb(210 0% 87.5% / 0.2)", "rgba(0, 16, 32, 0.2)", +"hwb(210deg 0% 87.5% / 1)", "rgb(0, 16, 32)", +"hwb(210 0% 87.5% / 1)", "rgb(0, 16, 32)", +"hwb(210deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(210 0% 100%)", "rgb(0, 0, 0)", +"hwb(210deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(210 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(210deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(210 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(210deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(210 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(210deg 12.5% 0%)", "rgb(32, 143, 255)", +"hwb(210 12.5% 0%)", "rgb(32, 143, 255)", +"hwb(210deg 12.5% 0% / 0)", "rgba(32, 143, 255, 0)", +"hwb(210 12.5% 0% / 0)", "rgba(32, 143, 255, 0)", +"hwb(210deg 12.5% 0% / 0.2)", "rgba(32, 143, 255, 0.2)", +"hwb(210 12.5% 0% / 0.2)", "rgba(32, 143, 255, 0.2)", +"hwb(210deg 12.5% 0% / 1)", "rgb(32, 143, 255)", +"hwb(210 12.5% 0% / 1)", "rgb(32, 143, 255)", +"hwb(210deg 12.5% 12.5%)", "rgb(32, 128, 223)", +"hwb(210 12.5% 12.5%)", "rgb(32, 128, 223)", +"hwb(210deg 12.5% 12.5% / 0)", "rgba(32, 128, 223, 0)", +"hwb(210 12.5% 12.5% / 0)", "rgba(32, 128, 223, 0)", +"hwb(210deg 12.5% 12.5% / 0.2)", "rgba(32, 128, 223, 0.2)", +"hwb(210 12.5% 12.5% / 0.2)", "rgba(32, 128, 223, 0.2)", +"hwb(210deg 12.5% 12.5% / 1)", "rgb(32, 128, 223)", +"hwb(210 12.5% 12.5% / 1)", "rgb(32, 128, 223)", +"hwb(210deg 12.5% 25%)", "rgb(32, 112, 191)", +"hwb(210 12.5% 25%)", "rgb(32, 112, 191)", +"hwb(210deg 12.5% 25% / 0)", "rgba(32, 112, 191, 0)", +"hwb(210 12.5% 25% / 0)", "rgba(32, 112, 191, 0)", +"hwb(210deg 12.5% 25% / 0.2)", "rgba(32, 112, 191, 0.2)", +"hwb(210 12.5% 25% / 0.2)", "rgba(32, 112, 191, 0.2)", +"hwb(210deg 12.5% 25% / 1)", "rgb(32, 112, 191)", +"hwb(210 12.5% 25% / 1)", "rgb(32, 112, 191)", +"hwb(210deg 12.5% 37.5%)", "rgb(32, 96, 159)", +"hwb(210 12.5% 37.5%)", "rgb(32, 96, 159)", +"hwb(210deg 12.5% 37.5% / 0)", "rgba(32, 96, 159, 0)", +"hwb(210 12.5% 37.5% / 0)", "rgba(32, 96, 159, 0)", +"hwb(210deg 12.5% 37.5% / 0.2)", "rgba(32, 96, 159, 0.2)", +"hwb(210 12.5% 37.5% / 0.2)", "rgba(32, 96, 159, 0.2)", +"hwb(210deg 12.5% 37.5% / 1)", "rgb(32, 96, 159)", +"hwb(210 12.5% 37.5% / 1)", "rgb(32, 96, 159)", +"hwb(210deg 12.5% 50%)", "rgb(32, 80, 128)", +"hwb(210 12.5% 50%)", "rgb(32, 80, 128)", +"hwb(210deg 12.5% 50% / 0)", "rgba(32, 80, 128, 0)", +"hwb(210 12.5% 50% / 0)", "rgba(32, 80, 128, 0)", +"hwb(210deg 12.5% 50% / 0.2)", "rgba(32, 80, 128, 0.2)", +"hwb(210 12.5% 50% / 0.2)", "rgba(32, 80, 128, 0.2)", +"hwb(210deg 12.5% 50% / 1)", "rgb(32, 80, 128)", +"hwb(210 12.5% 50% / 1)", "rgb(32, 80, 128)", +"hwb(210deg 12.5% 62.5%)", "rgb(32, 64, 96)", +"hwb(210 12.5% 62.5%)", "rgb(32, 64, 96)", +"hwb(210deg 12.5% 62.5% / 0)", "rgba(32, 64, 96, 0)", +"hwb(210 12.5% 62.5% / 0)", "rgba(32, 64, 96, 0)", +"hwb(210deg 12.5% 62.5% / 0.2)", "rgba(32, 64, 96, 0.2)", +"hwb(210 12.5% 62.5% / 0.2)", "rgba(32, 64, 96, 0.2)", +"hwb(210deg 12.5% 62.5% / 1)", "rgb(32, 64, 96)", +"hwb(210 12.5% 62.5% / 1)", "rgb(32, 64, 96)", +"hwb(210deg 12.5% 75%)", "rgb(32, 48, 64)", +"hwb(210 12.5% 75%)", "rgb(32, 48, 64)", +"hwb(210deg 12.5% 75% / 0)", "rgba(32, 48, 64, 0)", +"hwb(210 12.5% 75% / 0)", "rgba(32, 48, 64, 0)", +"hwb(210deg 12.5% 75% / 0.2)", "rgba(32, 48, 64, 0.2)", +"hwb(210 12.5% 75% / 0.2)", "rgba(32, 48, 64, 0.2)", +"hwb(210deg 12.5% 75% / 1)", "rgb(32, 48, 64)", +"hwb(210 12.5% 75% / 1)", "rgb(32, 48, 64)", +"hwb(210deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(210 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(210deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(210 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(210deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(210 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(210deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(210 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(210deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(210 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(210deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(210 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(210deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(210 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(210deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(210 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(210deg 25% 0%)", "rgb(64, 159, 255)", +"hwb(210 25% 0%)", "rgb(64, 159, 255)", +"hwb(210deg 25% 0% / 0)", "rgba(64, 159, 255, 0)", +"hwb(210 25% 0% / 0)", "rgba(64, 159, 255, 0)", +"hwb(210deg 25% 0% / 0.2)", "rgba(64, 159, 255, 0.2)", +"hwb(210 25% 0% / 0.2)", "rgba(64, 159, 255, 0.2)", +"hwb(210deg 25% 0% / 1)", "rgb(64, 159, 255)", +"hwb(210 25% 0% / 1)", "rgb(64, 159, 255)", +"hwb(210deg 25% 12.5%)", "rgb(64, 143, 223)", +"hwb(210 25% 12.5%)", "rgb(64, 143, 223)", +"hwb(210deg 25% 12.5% / 0)", "rgba(64, 143, 223, 0)", +"hwb(210 25% 12.5% / 0)", "rgba(64, 143, 223, 0)", +"hwb(210deg 25% 12.5% / 0.2)", "rgba(64, 143, 223, 0.2)", +"hwb(210 25% 12.5% / 0.2)", "rgba(64, 143, 223, 0.2)", +"hwb(210deg 25% 12.5% / 1)", "rgb(64, 143, 223)", +"hwb(210 25% 12.5% / 1)", "rgb(64, 143, 223)", +"hwb(210deg 25% 25%)", "rgb(64, 128, 191)", +"hwb(210 25% 25%)", "rgb(64, 128, 191)", +"hwb(210deg 25% 25% / 0)", "rgba(64, 128, 191, 0)", +"hwb(210 25% 25% / 0)", "rgba(64, 128, 191, 0)", +"hwb(210deg 25% 25% / 0.2)", "rgba(64, 128, 191, 0.2)", +"hwb(210 25% 25% / 0.2)", "rgba(64, 128, 191, 0.2)", +"hwb(210deg 25% 25% / 1)", "rgb(64, 128, 191)", +"hwb(210 25% 25% / 1)", "rgb(64, 128, 191)", +"hwb(210deg 25% 37.5%)", "rgb(64, 112, 159)", +"hwb(210 25% 37.5%)", "rgb(64, 112, 159)", +"hwb(210deg 25% 37.5% / 0)", "rgba(64, 112, 159, 0)", +"hwb(210 25% 37.5% / 0)", "rgba(64, 112, 159, 0)", +"hwb(210deg 25% 37.5% / 0.2)", "rgba(64, 112, 159, 0.2)", +"hwb(210 25% 37.5% / 0.2)", "rgba(64, 112, 159, 0.2)", +"hwb(210deg 25% 37.5% / 1)", "rgb(64, 112, 159)", +"hwb(210 25% 37.5% / 1)", "rgb(64, 112, 159)", +"hwb(210deg 25% 50%)", "rgb(64, 96, 128)", +"hwb(210 25% 50%)", "rgb(64, 96, 128)", +"hwb(210deg 25% 50% / 0)", "rgba(64, 96, 128, 0)", +"hwb(210 25% 50% / 0)", "rgba(64, 96, 128, 0)", +"hwb(210deg 25% 50% / 0.2)", "rgba(64, 96, 128, 0.2)", +"hwb(210 25% 50% / 0.2)", "rgba(64, 96, 128, 0.2)", +"hwb(210deg 25% 50% / 1)", "rgb(64, 96, 128)", +"hwb(210 25% 50% / 1)", "rgb(64, 96, 128)", +"hwb(210deg 25% 62.5%)", "rgb(64, 80, 96)", +"hwb(210 25% 62.5%)", "rgb(64, 80, 96)", +"hwb(210deg 25% 62.5% / 0)", "rgba(64, 80, 96, 0)", +"hwb(210 25% 62.5% / 0)", "rgba(64, 80, 96, 0)", +"hwb(210deg 25% 62.5% / 0.2)", "rgba(64, 80, 96, 0.2)", +"hwb(210 25% 62.5% / 0.2)", "rgba(64, 80, 96, 0.2)", +"hwb(210deg 25% 62.5% / 1)", "rgb(64, 80, 96)", +"hwb(210 25% 62.5% / 1)", "rgb(64, 80, 96)", +"hwb(210deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(210 25% 75%)", "rgb(64, 64, 64)", +"hwb(210deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(210 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(210deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(210 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(210deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(210 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(210deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(210 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(210deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(210 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(210deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(210 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(210deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(210 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(210deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(210 25% 100%)", "rgb(51, 51, 51)", +"hwb(210deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(210 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(210deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(210 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(210deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(210 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(210deg 37.5% 0%)", "rgb(96, 175, 255)", +"hwb(210 37.5% 0%)", "rgb(96, 175, 255)", +"hwb(210deg 37.5% 0% / 0)", "rgba(96, 175, 255, 0)", +"hwb(210 37.5% 0% / 0)", "rgba(96, 175, 255, 0)", +"hwb(210deg 37.5% 0% / 0.2)", "rgba(96, 175, 255, 0.2)", +"hwb(210 37.5% 0% / 0.2)", "rgba(96, 175, 255, 0.2)", +"hwb(210deg 37.5% 0% / 1)", "rgb(96, 175, 255)", +"hwb(210 37.5% 0% / 1)", "rgb(96, 175, 255)", +"hwb(210deg 37.5% 12.5%)", "rgb(96, 159, 223)", +"hwb(210 37.5% 12.5%)", "rgb(96, 159, 223)", +"hwb(210deg 37.5% 12.5% / 0)", "rgba(96, 159, 223, 0)", +"hwb(210 37.5% 12.5% / 0)", "rgba(96, 159, 223, 0)", +"hwb(210deg 37.5% 12.5% / 0.2)", "rgba(96, 159, 223, 0.2)", +"hwb(210 37.5% 12.5% / 0.2)", "rgba(96, 159, 223, 0.2)", +"hwb(210deg 37.5% 12.5% / 1)", "rgb(96, 159, 223)", +"hwb(210 37.5% 12.5% / 1)", "rgb(96, 159, 223)", +"hwb(210deg 37.5% 25%)", "rgb(96, 143, 191)", +"hwb(210 37.5% 25%)", "rgb(96, 143, 191)", +"hwb(210deg 37.5% 25% / 0)", "rgba(96, 143, 191, 0)", +"hwb(210 37.5% 25% / 0)", "rgba(96, 143, 191, 0)", +"hwb(210deg 37.5% 25% / 0.2)", "rgba(96, 143, 191, 0.2)", +"hwb(210 37.5% 25% / 0.2)", "rgba(96, 143, 191, 0.2)", +"hwb(210deg 37.5% 25% / 1)", "rgb(96, 143, 191)", +"hwb(210 37.5% 25% / 1)", "rgb(96, 143, 191)", +"hwb(210deg 37.5% 37.5%)", "rgb(96, 128, 159)", +"hwb(210 37.5% 37.5%)", "rgb(96, 128, 159)", +"hwb(210deg 37.5% 37.5% / 0)", "rgba(96, 128, 159, 0)", +"hwb(210 37.5% 37.5% / 0)", "rgba(96, 128, 159, 0)", +"hwb(210deg 37.5% 37.5% / 0.2)", "rgba(96, 128, 159, 0.2)", +"hwb(210 37.5% 37.5% / 0.2)", "rgba(96, 128, 159, 0.2)", +"hwb(210deg 37.5% 37.5% / 1)", "rgb(96, 128, 159)", +"hwb(210 37.5% 37.5% / 1)", "rgb(96, 128, 159)", +"hwb(210deg 37.5% 50%)", "rgb(96, 112, 128)", +"hwb(210 37.5% 50%)", "rgb(96, 112, 128)", +"hwb(210deg 37.5% 50% / 0)", "rgba(96, 112, 128, 0)", +"hwb(210 37.5% 50% / 0)", "rgba(96, 112, 128, 0)", +"hwb(210deg 37.5% 50% / 0.2)", "rgba(96, 112, 128, 0.2)", +"hwb(210 37.5% 50% / 0.2)", "rgba(96, 112, 128, 0.2)", +"hwb(210deg 37.5% 50% / 1)", "rgb(96, 112, 128)", +"hwb(210 37.5% 50% / 1)", "rgb(96, 112, 128)", +"hwb(210deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(210 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(210deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(210 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(210deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(210 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(210deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(210 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(210deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(210 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(210deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(210 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(210deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(210 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(210deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(210 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(210deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(210 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(210deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(210 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(210deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(210 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(210deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(210 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(210deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(210 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(210deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(210 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(210deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(210 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(210deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(210 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(210deg 50% 0%)", "rgb(128, 191, 255)", +"hwb(210 50% 0%)", "rgb(128, 191, 255)", +"hwb(210deg 50% 0% / 0)", "rgba(128, 191, 255, 0)", +"hwb(210 50% 0% / 0)", "rgba(128, 191, 255, 0)", +"hwb(210deg 50% 0% / 0.2)", "rgba(128, 191, 255, 0.2)", +"hwb(210 50% 0% / 0.2)", "rgba(128, 191, 255, 0.2)", +"hwb(210deg 50% 0% / 1)", "rgb(128, 191, 255)", +"hwb(210 50% 0% / 1)", "rgb(128, 191, 255)", +"hwb(210deg 50% 12.5%)", "rgb(128, 175, 223)", +"hwb(210 50% 12.5%)", "rgb(128, 175, 223)", +"hwb(210deg 50% 12.5% / 0)", "rgba(128, 175, 223, 0)", +"hwb(210 50% 12.5% / 0)", "rgba(128, 175, 223, 0)", +"hwb(210deg 50% 12.5% / 0.2)", "rgba(128, 175, 223, 0.2)", +"hwb(210 50% 12.5% / 0.2)", "rgba(128, 175, 223, 0.2)", +"hwb(210deg 50% 12.5% / 1)", "rgb(128, 175, 223)", +"hwb(210 50% 12.5% / 1)", "rgb(128, 175, 223)", +"hwb(210deg 50% 25%)", "rgb(128, 159, 191)", +"hwb(210 50% 25%)", "rgb(128, 159, 191)", +"hwb(210deg 50% 25% / 0)", "rgba(128, 159, 191, 0)", +"hwb(210 50% 25% / 0)", "rgba(128, 159, 191, 0)", +"hwb(210deg 50% 25% / 0.2)", "rgba(128, 159, 191, 0.2)", +"hwb(210 50% 25% / 0.2)", "rgba(128, 159, 191, 0.2)", +"hwb(210deg 50% 25% / 1)", "rgb(128, 159, 191)", +"hwb(210 50% 25% / 1)", "rgb(128, 159, 191)", +"hwb(210deg 50% 37.5%)", "rgb(128, 143, 159)", +"hwb(210 50% 37.5%)", "rgb(128, 143, 159)", +"hwb(210deg 50% 37.5% / 0)", "rgba(128, 143, 159, 0)", +"hwb(210 50% 37.5% / 0)", "rgba(128, 143, 159, 0)", +"hwb(210deg 50% 37.5% / 0.2)", "rgba(128, 143, 159, 0.2)", +"hwb(210 50% 37.5% / 0.2)", "rgba(128, 143, 159, 0.2)", +"hwb(210deg 50% 37.5% / 1)", "rgb(128, 143, 159)", +"hwb(210 50% 37.5% / 1)", "rgb(128, 143, 159)", +"hwb(210deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(210 50% 50%)", "rgb(128, 128, 128)", +"hwb(210deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(210 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(210deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(210 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(210deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(210 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(210deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(210 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(210deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(210 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(210deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(210 50% 75%)", "rgb(102, 102, 102)", +"hwb(210deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(210 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(210deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(210 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(210deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(210 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(210deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(210 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(210deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(210 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(210deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(210 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(210deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(210 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(210deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(210 50% 100%)", "rgb(85, 85, 85)", +"hwb(210deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(210 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(210deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(210 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(210deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(210 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(210deg 62.5% 0%)", "rgb(159, 207, 255)", +"hwb(210 62.5% 0%)", "rgb(159, 207, 255)", +"hwb(210deg 62.5% 0% / 0)", "rgba(159, 207, 255, 0)", +"hwb(210 62.5% 0% / 0)", "rgba(159, 207, 255, 0)", +"hwb(210deg 62.5% 0% / 0.2)", "rgba(159, 207, 255, 0.2)", +"hwb(210 62.5% 0% / 0.2)", "rgba(159, 207, 255, 0.2)", +"hwb(210deg 62.5% 0% / 1)", "rgb(159, 207, 255)", +"hwb(210 62.5% 0% / 1)", "rgb(159, 207, 255)", +"hwb(210deg 62.5% 12.5%)", "rgb(159, 191, 223)", +"hwb(210 62.5% 12.5%)", "rgb(159, 191, 223)", +"hwb(210deg 62.5% 12.5% / 0)", "rgba(159, 191, 223, 0)", +"hwb(210 62.5% 12.5% / 0)", "rgba(159, 191, 223, 0)", +"hwb(210deg 62.5% 12.5% / 0.2)", "rgba(159, 191, 223, 0.2)", +"hwb(210 62.5% 12.5% / 0.2)", "rgba(159, 191, 223, 0.2)", +"hwb(210deg 62.5% 12.5% / 1)", "rgb(159, 191, 223)", +"hwb(210 62.5% 12.5% / 1)", "rgb(159, 191, 223)", +"hwb(210deg 62.5% 25%)", "rgb(159, 175, 191)", +"hwb(210 62.5% 25%)", "rgb(159, 175, 191)", +"hwb(210deg 62.5% 25% / 0)", "rgba(159, 175, 191, 0)", +"hwb(210 62.5% 25% / 0)", "rgba(159, 175, 191, 0)", +"hwb(210deg 62.5% 25% / 0.2)", "rgba(159, 175, 191, 0.2)", +"hwb(210 62.5% 25% / 0.2)", "rgba(159, 175, 191, 0.2)", +"hwb(210deg 62.5% 25% / 1)", "rgb(159, 175, 191)", +"hwb(210 62.5% 25% / 1)", "rgb(159, 175, 191)", +"hwb(210deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(210 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(210deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(210 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(210deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(210 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(210deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(210 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(210deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(210 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(210deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(210 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(210deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(210 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(210deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(210 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(210deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(210 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(210deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(210 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(210deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(210 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(210deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(210 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(210deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(210 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(210deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(210 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(210deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(210 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(210deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(210 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(210deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(210 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(210deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(210 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(210deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(210 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(210deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(210 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(210deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(210 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(210deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(210 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(210deg 75% 0%)", "rgb(191, 223, 255)", +"hwb(210 75% 0%)", "rgb(191, 223, 255)", +"hwb(210deg 75% 0% / 0)", "rgba(191, 223, 255, 0)", +"hwb(210 75% 0% / 0)", "rgba(191, 223, 255, 0)", +"hwb(210deg 75% 0% / 0.2)", "rgba(191, 223, 255, 0.2)", +"hwb(210 75% 0% / 0.2)", "rgba(191, 223, 255, 0.2)", +"hwb(210deg 75% 0% / 1)", "rgb(191, 223, 255)", +"hwb(210 75% 0% / 1)", "rgb(191, 223, 255)", +"hwb(210deg 75% 12.5%)", "rgb(191, 207, 223)", +"hwb(210 75% 12.5%)", "rgb(191, 207, 223)", +"hwb(210deg 75% 12.5% / 0)", "rgba(191, 207, 223, 0)", +"hwb(210 75% 12.5% / 0)", "rgba(191, 207, 223, 0)", +"hwb(210deg 75% 12.5% / 0.2)", "rgba(191, 207, 223, 0.2)", +"hwb(210 75% 12.5% / 0.2)", "rgba(191, 207, 223, 0.2)", +"hwb(210deg 75% 12.5% / 1)", "rgb(191, 207, 223)", +"hwb(210 75% 12.5% / 1)", "rgb(191, 207, 223)", +"hwb(210deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(210 75% 25%)", "rgb(191, 191, 191)", +"hwb(210deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(210 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(210deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(210 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(210deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(210 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(210deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(210 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(210deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(210 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(210deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(210 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(210deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(210 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(210deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(210 75% 50%)", "rgb(153, 153, 153)", +"hwb(210deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(210 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(210deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(210 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(210deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(210 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(210deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(210 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(210deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(210 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(210deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(210 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(210deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(210 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(210deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(210 75% 75%)", "rgb(128, 128, 128)", +"hwb(210deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(210 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(210deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(210 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(210deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(210 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(210deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(210 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(210deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(210 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(210deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(210 75% 100%)", "rgb(109, 109, 109)", +"hwb(210deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(210 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(210deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(210 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(210deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(210 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(210deg 87.5% 0%)", "rgb(223, 239, 255)", +"hwb(210 87.5% 0%)", "rgb(223, 239, 255)", +"hwb(210deg 87.5% 0% / 0)", "rgba(223, 239, 255, 0)", +"hwb(210 87.5% 0% / 0)", "rgba(223, 239, 255, 0)", +"hwb(210deg 87.5% 0% / 0.2)", "rgba(223, 239, 255, 0.2)", +"hwb(210 87.5% 0% / 0.2)", "rgba(223, 239, 255, 0.2)", +"hwb(210deg 87.5% 0% / 1)", "rgb(223, 239, 255)", +"hwb(210 87.5% 0% / 1)", "rgb(223, 239, 255)", +"hwb(210deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(210 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(210deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(210 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(210deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(210 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(210deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(210 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(210deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(210 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(210deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(210 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(210deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(210 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(210deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(210 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(210deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(210 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(210deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(210 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(210deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(210 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(210deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(210 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(210deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(210 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(210deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(210 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(210deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(210 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(210deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(210 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(210deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(210 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(210deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(210 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(210deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(210 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(210deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(210 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(210deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(210 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(210deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(210 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(210deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(210 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(210deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(210 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(210deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(210 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(210deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(210 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(210deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(210 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(210deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(210 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(210deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(210 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(210deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(210 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(210deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(210 100% 0%)", "rgb(255, 255, 255)", +"hwb(210deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(210 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(210deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(210 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(210deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(210 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(210deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(210 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(210deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(210 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(210deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(210 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(210deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(210 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(210deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(210 100% 25%)", "rgb(204, 204, 204)", +"hwb(210deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(210 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(210deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(210 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(210deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(210 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(210deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(210 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(210deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(210 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(210deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(210 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(210deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(210 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(210deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(210 100% 50%)", "rgb(170, 170, 170)", +"hwb(210deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(210 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(210deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(210 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(210deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(210 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(210deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(210 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(210deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(210 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(210deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(210 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(210deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(210 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(210deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(210 100% 75%)", "rgb(146, 146, 146)", +"hwb(210deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(210 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(210deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(210 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(210deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(210 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(210deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(210 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(210deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(210 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(210deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(210 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(210deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(210 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(210deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(210 100% 100%)", "rgb(128, 128, 128)", +"hwb(210deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(210deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(210deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(210 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(240deg 0% 0%)", "rgb(0, 0, 255)", +"hwb(240 0% 0%)", "rgb(0, 0, 255)", +"hwb(240deg 0% 0% / 0)", "rgba(0, 0, 255, 0)", +"hwb(240 0% 0% / 0)", "rgba(0, 0, 255, 0)", +"hwb(240deg 0% 0% / 0.2)", "rgba(0, 0, 255, 0.2)", +"hwb(240 0% 0% / 0.2)", "rgba(0, 0, 255, 0.2)", +"hwb(240deg 0% 0% / 1)", "rgb(0, 0, 255)", +"hwb(240 0% 0% / 1)", "rgb(0, 0, 255)", +"hwb(240deg 0% 12.5%)", "rgb(0, 0, 223)", +"hwb(240 0% 12.5%)", "rgb(0, 0, 223)", +"hwb(240deg 0% 12.5% / 0)", "rgba(0, 0, 223, 0)", +"hwb(240 0% 12.5% / 0)", "rgba(0, 0, 223, 0)", +"hwb(240deg 0% 12.5% / 0.2)", "rgba(0, 0, 223, 0.2)", +"hwb(240 0% 12.5% / 0.2)", "rgba(0, 0, 223, 0.2)", +"hwb(240deg 0% 12.5% / 1)", "rgb(0, 0, 223)", +"hwb(240 0% 12.5% / 1)", "rgb(0, 0, 223)", +"hwb(240deg 0% 25%)", "rgb(0, 0, 191)", +"hwb(240 0% 25%)", "rgb(0, 0, 191)", +"hwb(240deg 0% 25% / 0)", "rgba(0, 0, 191, 0)", +"hwb(240 0% 25% / 0)", "rgba(0, 0, 191, 0)", +"hwb(240deg 0% 25% / 0.2)", "rgba(0, 0, 191, 0.2)", +"hwb(240 0% 25% / 0.2)", "rgba(0, 0, 191, 0.2)", +"hwb(240deg 0% 25% / 1)", "rgb(0, 0, 191)", +"hwb(240 0% 25% / 1)", "rgb(0, 0, 191)", +"hwb(240deg 0% 37.5%)", "rgb(0, 0, 159)", +"hwb(240 0% 37.5%)", "rgb(0, 0, 159)", +"hwb(240deg 0% 37.5% / 0)", "rgba(0, 0, 159, 0)", +"hwb(240 0% 37.5% / 0)", "rgba(0, 0, 159, 0)", +"hwb(240deg 0% 37.5% / 0.2)", "rgba(0, 0, 159, 0.2)", +"hwb(240 0% 37.5% / 0.2)", "rgba(0, 0, 159, 0.2)", +"hwb(240deg 0% 37.5% / 1)", "rgb(0, 0, 159)", +"hwb(240 0% 37.5% / 1)", "rgb(0, 0, 159)", +"hwb(240deg 0% 50%)", "rgb(0, 0, 128)", +"hwb(240 0% 50%)", "rgb(0, 0, 128)", +"hwb(240deg 0% 50% / 0)", "rgba(0, 0, 128, 0)", +"hwb(240 0% 50% / 0)", "rgba(0, 0, 128, 0)", +"hwb(240deg 0% 50% / 0.2)", "rgba(0, 0, 128, 0.2)", +"hwb(240 0% 50% / 0.2)", "rgba(0, 0, 128, 0.2)", +"hwb(240deg 0% 50% / 1)", "rgb(0, 0, 128)", +"hwb(240 0% 50% / 1)", "rgb(0, 0, 128)", +"hwb(240deg 0% 62.5%)", "rgb(0, 0, 96)", +"hwb(240 0% 62.5%)", "rgb(0, 0, 96)", +"hwb(240deg 0% 62.5% / 0)", "rgba(0, 0, 96, 0)", +"hwb(240 0% 62.5% / 0)", "rgba(0, 0, 96, 0)", +"hwb(240deg 0% 62.5% / 0.2)", "rgba(0, 0, 96, 0.2)", +"hwb(240 0% 62.5% / 0.2)", "rgba(0, 0, 96, 0.2)", +"hwb(240deg 0% 62.5% / 1)", "rgb(0, 0, 96)", +"hwb(240 0% 62.5% / 1)", "rgb(0, 0, 96)", +"hwb(240deg 0% 75%)", "rgb(0, 0, 64)", +"hwb(240 0% 75%)", "rgb(0, 0, 64)", +"hwb(240deg 0% 75% / 0)", "rgba(0, 0, 64, 0)", +"hwb(240 0% 75% / 0)", "rgba(0, 0, 64, 0)", +"hwb(240deg 0% 75% / 0.2)", "rgba(0, 0, 64, 0.2)", +"hwb(240 0% 75% / 0.2)", "rgba(0, 0, 64, 0.2)", +"hwb(240deg 0% 75% / 1)", "rgb(0, 0, 64)", +"hwb(240 0% 75% / 1)", "rgb(0, 0, 64)", +"hwb(240deg 0% 87.5%)", "rgb(0, 0, 32)", +"hwb(240 0% 87.5%)", "rgb(0, 0, 32)", +"hwb(240deg 0% 87.5% / 0)", "rgba(0, 0, 32, 0)", +"hwb(240 0% 87.5% / 0)", "rgba(0, 0, 32, 0)", +"hwb(240deg 0% 87.5% / 0.2)", "rgba(0, 0, 32, 0.2)", +"hwb(240 0% 87.5% / 0.2)", "rgba(0, 0, 32, 0.2)", +"hwb(240deg 0% 87.5% / 1)", "rgb(0, 0, 32)", +"hwb(240 0% 87.5% / 1)", "rgb(0, 0, 32)", +"hwb(240deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(240 0% 100%)", "rgb(0, 0, 0)", +"hwb(240deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(240 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(240deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(240 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(240deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(240 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(240deg 12.5% 0%)", "rgb(32, 32, 255)", +"hwb(240 12.5% 0%)", "rgb(32, 32, 255)", +"hwb(240deg 12.5% 0% / 0)", "rgba(32, 32, 255, 0)", +"hwb(240 12.5% 0% / 0)", "rgba(32, 32, 255, 0)", +"hwb(240deg 12.5% 0% / 0.2)", "rgba(32, 32, 255, 0.2)", +"hwb(240 12.5% 0% / 0.2)", "rgba(32, 32, 255, 0.2)", +"hwb(240deg 12.5% 0% / 1)", "rgb(32, 32, 255)", +"hwb(240 12.5% 0% / 1)", "rgb(32, 32, 255)", +"hwb(240deg 12.5% 12.5%)", "rgb(32, 32, 223)", +"hwb(240 12.5% 12.5%)", "rgb(32, 32, 223)", +"hwb(240deg 12.5% 12.5% / 0)", "rgba(32, 32, 223, 0)", +"hwb(240 12.5% 12.5% / 0)", "rgba(32, 32, 223, 0)", +"hwb(240deg 12.5% 12.5% / 0.2)", "rgba(32, 32, 223, 0.2)", +"hwb(240 12.5% 12.5% / 0.2)", "rgba(32, 32, 223, 0.2)", +"hwb(240deg 12.5% 12.5% / 1)", "rgb(32, 32, 223)", +"hwb(240 12.5% 12.5% / 1)", "rgb(32, 32, 223)", +"hwb(240deg 12.5% 25%)", "rgb(32, 32, 191)", +"hwb(240 12.5% 25%)", "rgb(32, 32, 191)", +"hwb(240deg 12.5% 25% / 0)", "rgba(32, 32, 191, 0)", +"hwb(240 12.5% 25% / 0)", "rgba(32, 32, 191, 0)", +"hwb(240deg 12.5% 25% / 0.2)", "rgba(32, 32, 191, 0.2)", +"hwb(240 12.5% 25% / 0.2)", "rgba(32, 32, 191, 0.2)", +"hwb(240deg 12.5% 25% / 1)", "rgb(32, 32, 191)", +"hwb(240 12.5% 25% / 1)", "rgb(32, 32, 191)", +"hwb(240deg 12.5% 37.5%)", "rgb(32, 32, 159)", +"hwb(240 12.5% 37.5%)", "rgb(32, 32, 159)", +"hwb(240deg 12.5% 37.5% / 0)", "rgba(32, 32, 159, 0)", +"hwb(240 12.5% 37.5% / 0)", "rgba(32, 32, 159, 0)", +"hwb(240deg 12.5% 37.5% / 0.2)", "rgba(32, 32, 159, 0.2)", +"hwb(240 12.5% 37.5% / 0.2)", "rgba(32, 32, 159, 0.2)", +"hwb(240deg 12.5% 37.5% / 1)", "rgb(32, 32, 159)", +"hwb(240 12.5% 37.5% / 1)", "rgb(32, 32, 159)", +"hwb(240deg 12.5% 50%)", "rgb(32, 32, 128)", +"hwb(240 12.5% 50%)", "rgb(32, 32, 128)", +"hwb(240deg 12.5% 50% / 0)", "rgba(32, 32, 128, 0)", +"hwb(240 12.5% 50% / 0)", "rgba(32, 32, 128, 0)", +"hwb(240deg 12.5% 50% / 0.2)", "rgba(32, 32, 128, 0.2)", +"hwb(240 12.5% 50% / 0.2)", "rgba(32, 32, 128, 0.2)", +"hwb(240deg 12.5% 50% / 1)", "rgb(32, 32, 128)", +"hwb(240 12.5% 50% / 1)", "rgb(32, 32, 128)", +"hwb(240deg 12.5% 62.5%)", "rgb(32, 32, 96)", +"hwb(240 12.5% 62.5%)", "rgb(32, 32, 96)", +"hwb(240deg 12.5% 62.5% / 0)", "rgba(32, 32, 96, 0)", +"hwb(240 12.5% 62.5% / 0)", "rgba(32, 32, 96, 0)", +"hwb(240deg 12.5% 62.5% / 0.2)", "rgba(32, 32, 96, 0.2)", +"hwb(240 12.5% 62.5% / 0.2)", "rgba(32, 32, 96, 0.2)", +"hwb(240deg 12.5% 62.5% / 1)", "rgb(32, 32, 96)", +"hwb(240 12.5% 62.5% / 1)", "rgb(32, 32, 96)", +"hwb(240deg 12.5% 75%)", "rgb(32, 32, 64)", +"hwb(240 12.5% 75%)", "rgb(32, 32, 64)", +"hwb(240deg 12.5% 75% / 0)", "rgba(32, 32, 64, 0)", +"hwb(240 12.5% 75% / 0)", "rgba(32, 32, 64, 0)", +"hwb(240deg 12.5% 75% / 0.2)", "rgba(32, 32, 64, 0.2)", +"hwb(240 12.5% 75% / 0.2)", "rgba(32, 32, 64, 0.2)", +"hwb(240deg 12.5% 75% / 1)", "rgb(32, 32, 64)", +"hwb(240 12.5% 75% / 1)", "rgb(32, 32, 64)", +"hwb(240deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(240 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(240deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(240 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(240deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(240 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(240deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(240 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(240deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(240 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(240deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(240 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(240deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(240 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(240deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(240 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(240deg 25% 0%)", "rgb(64, 64, 255)", +"hwb(240 25% 0%)", "rgb(64, 64, 255)", +"hwb(240deg 25% 0% / 0)", "rgba(64, 64, 255, 0)", +"hwb(240 25% 0% / 0)", "rgba(64, 64, 255, 0)", +"hwb(240deg 25% 0% / 0.2)", "rgba(64, 64, 255, 0.2)", +"hwb(240 25% 0% / 0.2)", "rgba(64, 64, 255, 0.2)", +"hwb(240deg 25% 0% / 1)", "rgb(64, 64, 255)", +"hwb(240 25% 0% / 1)", "rgb(64, 64, 255)", +"hwb(240deg 25% 12.5%)", "rgb(64, 64, 223)", +"hwb(240 25% 12.5%)", "rgb(64, 64, 223)", +"hwb(240deg 25% 12.5% / 0)", "rgba(64, 64, 223, 0)", +"hwb(240 25% 12.5% / 0)", "rgba(64, 64, 223, 0)", +"hwb(240deg 25% 12.5% / 0.2)", "rgba(64, 64, 223, 0.2)", +"hwb(240 25% 12.5% / 0.2)", "rgba(64, 64, 223, 0.2)", +"hwb(240deg 25% 12.5% / 1)", "rgb(64, 64, 223)", +"hwb(240 25% 12.5% / 1)", "rgb(64, 64, 223)", +"hwb(240deg 25% 25%)", "rgb(64, 64, 191)", +"hwb(240 25% 25%)", "rgb(64, 64, 191)", +"hwb(240deg 25% 25% / 0)", "rgba(64, 64, 191, 0)", +"hwb(240 25% 25% / 0)", "rgba(64, 64, 191, 0)", +"hwb(240deg 25% 25% / 0.2)", "rgba(64, 64, 191, 0.2)", +"hwb(240 25% 25% / 0.2)", "rgba(64, 64, 191, 0.2)", +"hwb(240deg 25% 25% / 1)", "rgb(64, 64, 191)", +"hwb(240 25% 25% / 1)", "rgb(64, 64, 191)", +"hwb(240deg 25% 37.5%)", "rgb(64, 64, 159)", +"hwb(240 25% 37.5%)", "rgb(64, 64, 159)", +"hwb(240deg 25% 37.5% / 0)", "rgba(64, 64, 159, 0)", +"hwb(240 25% 37.5% / 0)", "rgba(64, 64, 159, 0)", +"hwb(240deg 25% 37.5% / 0.2)", "rgba(64, 64, 159, 0.2)", +"hwb(240 25% 37.5% / 0.2)", "rgba(64, 64, 159, 0.2)", +"hwb(240deg 25% 37.5% / 1)", "rgb(64, 64, 159)", +"hwb(240 25% 37.5% / 1)", "rgb(64, 64, 159)", +"hwb(240deg 25% 50%)", "rgb(64, 64, 128)", +"hwb(240 25% 50%)", "rgb(64, 64, 128)", +"hwb(240deg 25% 50% / 0)", "rgba(64, 64, 128, 0)", +"hwb(240 25% 50% / 0)", "rgba(64, 64, 128, 0)", +"hwb(240deg 25% 50% / 0.2)", "rgba(64, 64, 128, 0.2)", +"hwb(240 25% 50% / 0.2)", "rgba(64, 64, 128, 0.2)", +"hwb(240deg 25% 50% / 1)", "rgb(64, 64, 128)", +"hwb(240 25% 50% / 1)", "rgb(64, 64, 128)", +"hwb(240deg 25% 62.5%)", "rgb(64, 64, 96)", +"hwb(240 25% 62.5%)", "rgb(64, 64, 96)", +"hwb(240deg 25% 62.5% / 0)", "rgba(64, 64, 96, 0)", +"hwb(240 25% 62.5% / 0)", "rgba(64, 64, 96, 0)", +"hwb(240deg 25% 62.5% / 0.2)", "rgba(64, 64, 96, 0.2)", +"hwb(240 25% 62.5% / 0.2)", "rgba(64, 64, 96, 0.2)", +"hwb(240deg 25% 62.5% / 1)", "rgb(64, 64, 96)", +"hwb(240 25% 62.5% / 1)", "rgb(64, 64, 96)", +"hwb(240deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(240 25% 75%)", "rgb(64, 64, 64)", +"hwb(240deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(240 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(240deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(240 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(240deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(240 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(240deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(240 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(240deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(240 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(240deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(240 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(240deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(240 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(240deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(240 25% 100%)", "rgb(51, 51, 51)", +"hwb(240deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(240 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(240deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(240 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(240deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(240 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(240deg 37.5% 0%)", "rgb(96, 96, 255)", +"hwb(240 37.5% 0%)", "rgb(96, 96, 255)", +"hwb(240deg 37.5% 0% / 0)", "rgba(96, 96, 255, 0)", +"hwb(240 37.5% 0% / 0)", "rgba(96, 96, 255, 0)", +"hwb(240deg 37.5% 0% / 0.2)", "rgba(96, 96, 255, 0.2)", +"hwb(240 37.5% 0% / 0.2)", "rgba(96, 96, 255, 0.2)", +"hwb(240deg 37.5% 0% / 1)", "rgb(96, 96, 255)", +"hwb(240 37.5% 0% / 1)", "rgb(96, 96, 255)", +"hwb(240deg 37.5% 12.5%)", "rgb(96, 96, 223)", +"hwb(240 37.5% 12.5%)", "rgb(96, 96, 223)", +"hwb(240deg 37.5% 12.5% / 0)", "rgba(96, 96, 223, 0)", +"hwb(240 37.5% 12.5% / 0)", "rgba(96, 96, 223, 0)", +"hwb(240deg 37.5% 12.5% / 0.2)", "rgba(96, 96, 223, 0.2)", +"hwb(240 37.5% 12.5% / 0.2)", "rgba(96, 96, 223, 0.2)", +"hwb(240deg 37.5% 12.5% / 1)", "rgb(96, 96, 223)", +"hwb(240 37.5% 12.5% / 1)", "rgb(96, 96, 223)", +"hwb(240deg 37.5% 25%)", "rgb(96, 96, 191)", +"hwb(240 37.5% 25%)", "rgb(96, 96, 191)", +"hwb(240deg 37.5% 25% / 0)", "rgba(96, 96, 191, 0)", +"hwb(240 37.5% 25% / 0)", "rgba(96, 96, 191, 0)", +"hwb(240deg 37.5% 25% / 0.2)", "rgba(96, 96, 191, 0.2)", +"hwb(240 37.5% 25% / 0.2)", "rgba(96, 96, 191, 0.2)", +"hwb(240deg 37.5% 25% / 1)", "rgb(96, 96, 191)", +"hwb(240 37.5% 25% / 1)", "rgb(96, 96, 191)", +"hwb(240deg 37.5% 37.5%)", "rgb(96, 96, 159)", +"hwb(240 37.5% 37.5%)", "rgb(96, 96, 159)", +"hwb(240deg 37.5% 37.5% / 0)", "rgba(96, 96, 159, 0)", +"hwb(240 37.5% 37.5% / 0)", "rgba(96, 96, 159, 0)", +"hwb(240deg 37.5% 37.5% / 0.2)", "rgba(96, 96, 159, 0.2)", +"hwb(240 37.5% 37.5% / 0.2)", "rgba(96, 96, 159, 0.2)", +"hwb(240deg 37.5% 37.5% / 1)", "rgb(96, 96, 159)", +"hwb(240 37.5% 37.5% / 1)", "rgb(96, 96, 159)", +"hwb(240deg 37.5% 50%)", "rgb(96, 96, 128)", +"hwb(240 37.5% 50%)", "rgb(96, 96, 128)", +"hwb(240deg 37.5% 50% / 0)", "rgba(96, 96, 128, 0)", +"hwb(240 37.5% 50% / 0)", "rgba(96, 96, 128, 0)", +"hwb(240deg 37.5% 50% / 0.2)", "rgba(96, 96, 128, 0.2)", +"hwb(240 37.5% 50% / 0.2)", "rgba(96, 96, 128, 0.2)", +"hwb(240deg 37.5% 50% / 1)", "rgb(96, 96, 128)", +"hwb(240 37.5% 50% / 1)", "rgb(96, 96, 128)", +"hwb(240deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(240 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(240deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(240 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(240deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(240 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(240deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(240 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(240deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(240 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(240deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(240 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(240deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(240 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(240deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(240 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(240deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(240 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(240deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(240 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(240deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(240 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(240deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(240 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(240deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(240 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(240deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(240 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(240deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(240 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(240deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(240 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(240deg 50% 0%)", "rgb(128, 128, 255)", +"hwb(240 50% 0%)", "rgb(128, 128, 255)", +"hwb(240deg 50% 0% / 0)", "rgba(128, 128, 255, 0)", +"hwb(240 50% 0% / 0)", "rgba(128, 128, 255, 0)", +"hwb(240deg 50% 0% / 0.2)", "rgba(128, 128, 255, 0.2)", +"hwb(240 50% 0% / 0.2)", "rgba(128, 128, 255, 0.2)", +"hwb(240deg 50% 0% / 1)", "rgb(128, 128, 255)", +"hwb(240 50% 0% / 1)", "rgb(128, 128, 255)", +"hwb(240deg 50% 12.5%)", "rgb(128, 128, 223)", +"hwb(240 50% 12.5%)", "rgb(128, 128, 223)", +"hwb(240deg 50% 12.5% / 0)", "rgba(128, 128, 223, 0)", +"hwb(240 50% 12.5% / 0)", "rgba(128, 128, 223, 0)", +"hwb(240deg 50% 12.5% / 0.2)", "rgba(128, 128, 223, 0.2)", +"hwb(240 50% 12.5% / 0.2)", "rgba(128, 128, 223, 0.2)", +"hwb(240deg 50% 12.5% / 1)", "rgb(128, 128, 223)", +"hwb(240 50% 12.5% / 1)", "rgb(128, 128, 223)", +"hwb(240deg 50% 25%)", "rgb(128, 128, 191)", +"hwb(240 50% 25%)", "rgb(128, 128, 191)", +"hwb(240deg 50% 25% / 0)", "rgba(128, 128, 191, 0)", +"hwb(240 50% 25% / 0)", "rgba(128, 128, 191, 0)", +"hwb(240deg 50% 25% / 0.2)", "rgba(128, 128, 191, 0.2)", +"hwb(240 50% 25% / 0.2)", "rgba(128, 128, 191, 0.2)", +"hwb(240deg 50% 25% / 1)", "rgb(128, 128, 191)", +"hwb(240 50% 25% / 1)", "rgb(128, 128, 191)", +"hwb(240deg 50% 37.5%)", "rgb(128, 128, 159)", +"hwb(240 50% 37.5%)", "rgb(128, 128, 159)", +"hwb(240deg 50% 37.5% / 0)", "rgba(128, 128, 159, 0)", +"hwb(240 50% 37.5% / 0)", "rgba(128, 128, 159, 0)", +"hwb(240deg 50% 37.5% / 0.2)", "rgba(128, 128, 159, 0.2)", +"hwb(240 50% 37.5% / 0.2)", "rgba(128, 128, 159, 0.2)", +"hwb(240deg 50% 37.5% / 1)", "rgb(128, 128, 159)", +"hwb(240 50% 37.5% / 1)", "rgb(128, 128, 159)", +"hwb(240deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(240 50% 50%)", "rgb(128, 128, 128)", +"hwb(240deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(240 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(240deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(240 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(240deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(240 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(240deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(240 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(240deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(240 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(240deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(240 50% 75%)", "rgb(102, 102, 102)", +"hwb(240deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(240 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(240deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(240 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(240deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(240 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(240deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(240 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(240deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(240 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(240deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(240 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(240deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(240 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(240deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(240 50% 100%)", "rgb(85, 85, 85)", +"hwb(240deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(240 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(240deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(240 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(240deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(240 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(240deg 62.5% 0%)", "rgb(159, 159, 255)", +"hwb(240 62.5% 0%)", "rgb(159, 159, 255)", +"hwb(240deg 62.5% 0% / 0)", "rgba(159, 159, 255, 0)", +"hwb(240 62.5% 0% / 0)", "rgba(159, 159, 255, 0)", +"hwb(240deg 62.5% 0% / 0.2)", "rgba(159, 159, 255, 0.2)", +"hwb(240 62.5% 0% / 0.2)", "rgba(159, 159, 255, 0.2)", +"hwb(240deg 62.5% 0% / 1)", "rgb(159, 159, 255)", +"hwb(240 62.5% 0% / 1)", "rgb(159, 159, 255)", +"hwb(240deg 62.5% 12.5%)", "rgb(159, 159, 223)", +"hwb(240 62.5% 12.5%)", "rgb(159, 159, 223)", +"hwb(240deg 62.5% 12.5% / 0)", "rgba(159, 159, 223, 0)", +"hwb(240 62.5% 12.5% / 0)", "rgba(159, 159, 223, 0)", +"hwb(240deg 62.5% 12.5% / 0.2)", "rgba(159, 159, 223, 0.2)", +"hwb(240 62.5% 12.5% / 0.2)", "rgba(159, 159, 223, 0.2)", +"hwb(240deg 62.5% 12.5% / 1)", "rgb(159, 159, 223)", +"hwb(240 62.5% 12.5% / 1)", "rgb(159, 159, 223)", +"hwb(240deg 62.5% 25%)", "rgb(159, 159, 191)", +"hwb(240 62.5% 25%)", "rgb(159, 159, 191)", +"hwb(240deg 62.5% 25% / 0)", "rgba(159, 159, 191, 0)", +"hwb(240 62.5% 25% / 0)", "rgba(159, 159, 191, 0)", +"hwb(240deg 62.5% 25% / 0.2)", "rgba(159, 159, 191, 0.2)", +"hwb(240 62.5% 25% / 0.2)", "rgba(159, 159, 191, 0.2)", +"hwb(240deg 62.5% 25% / 1)", "rgb(159, 159, 191)", +"hwb(240 62.5% 25% / 1)", "rgb(159, 159, 191)", +"hwb(240deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(240 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(240deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(240 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(240deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(240 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(240deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(240 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(240deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(240 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(240deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(240 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(240deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(240 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(240deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(240 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(240deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(240 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(240deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(240 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(240deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(240 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(240deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(240 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(240deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(240 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(240deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(240 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(240deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(240 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(240deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(240 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(240deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(240 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(240deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(240 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(240deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(240 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(240deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(240 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(240deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(240 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(240deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(240 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(240deg 75% 0%)", "rgb(191, 191, 255)", +"hwb(240 75% 0%)", "rgb(191, 191, 255)", +"hwb(240deg 75% 0% / 0)", "rgba(191, 191, 255, 0)", +"hwb(240 75% 0% / 0)", "rgba(191, 191, 255, 0)", +"hwb(240deg 75% 0% / 0.2)", "rgba(191, 191, 255, 0.2)", +"hwb(240 75% 0% / 0.2)", "rgba(191, 191, 255, 0.2)", +"hwb(240deg 75% 0% / 1)", "rgb(191, 191, 255)", +"hwb(240 75% 0% / 1)", "rgb(191, 191, 255)", +"hwb(240deg 75% 12.5%)", "rgb(191, 191, 223)", +"hwb(240 75% 12.5%)", "rgb(191, 191, 223)", +"hwb(240deg 75% 12.5% / 0)", "rgba(191, 191, 223, 0)", +"hwb(240 75% 12.5% / 0)", "rgba(191, 191, 223, 0)", +"hwb(240deg 75% 12.5% / 0.2)", "rgba(191, 191, 223, 0.2)", +"hwb(240 75% 12.5% / 0.2)", "rgba(191, 191, 223, 0.2)", +"hwb(240deg 75% 12.5% / 1)", "rgb(191, 191, 223)", +"hwb(240 75% 12.5% / 1)", "rgb(191, 191, 223)", +"hwb(240deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(240 75% 25%)", "rgb(191, 191, 191)", +"hwb(240deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(240 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(240deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(240 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(240deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(240 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(240deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(240 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(240deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(240 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(240deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(240 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(240deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(240 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(240deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(240 75% 50%)", "rgb(153, 153, 153)", +"hwb(240deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(240 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(240deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(240 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(240deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(240 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(240deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(240 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(240deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(240 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(240deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(240 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(240deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(240 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(240deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(240 75% 75%)", "rgb(128, 128, 128)", +"hwb(240deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(240 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(240deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(240 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(240deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(240 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(240deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(240 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(240deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(240 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(240deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(240 75% 100%)", "rgb(109, 109, 109)", +"hwb(240deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(240 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(240deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(240 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(240deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(240 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(240deg 87.5% 0%)", "rgb(223, 223, 255)", +"hwb(240 87.5% 0%)", "rgb(223, 223, 255)", +"hwb(240deg 87.5% 0% / 0)", "rgba(223, 223, 255, 0)", +"hwb(240 87.5% 0% / 0)", "rgba(223, 223, 255, 0)", +"hwb(240deg 87.5% 0% / 0.2)", "rgba(223, 223, 255, 0.2)", +"hwb(240 87.5% 0% / 0.2)", "rgba(223, 223, 255, 0.2)", +"hwb(240deg 87.5% 0% / 1)", "rgb(223, 223, 255)", +"hwb(240 87.5% 0% / 1)", "rgb(223, 223, 255)", +"hwb(240deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(240 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(240deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(240 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(240deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(240 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(240deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(240 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(240deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(240 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(240deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(240 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(240deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(240 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(240deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(240 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(240deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(240 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(240deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(240 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(240deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(240 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(240deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(240 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(240deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(240 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(240deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(240 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(240deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(240 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(240deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(240 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(240deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(240 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(240deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(240 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(240deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(240 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(240deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(240 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(240deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(240 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(240deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(240 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(240deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(240 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(240deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(240 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(240deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(240 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(240deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(240 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(240deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(240 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(240deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(240 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(240deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(240 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(240deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(240 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(240deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(240 100% 0%)", "rgb(255, 255, 255)", +"hwb(240deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(240 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(240deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(240 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(240deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(240 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(240deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(240 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(240deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(240 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(240deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(240 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(240deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(240 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(240deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(240 100% 25%)", "rgb(204, 204, 204)", +"hwb(240deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(240 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(240deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(240 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(240deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(240 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(240deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(240 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(240deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(240 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(240deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(240 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(240deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(240 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(240deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(240 100% 50%)", "rgb(170, 170, 170)", +"hwb(240deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(240 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(240deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(240 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(240deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(240 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(240deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(240 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(240deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(240 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(240deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(240 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(240deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(240 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(240deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(240 100% 75%)", "rgb(146, 146, 146)", +"hwb(240deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(240 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(240deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(240 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(240deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(240 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(240deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(240 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(240deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(240 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(240deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(240 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(240deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(240 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(240deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(240 100% 100%)", "rgb(128, 128, 128)", +"hwb(240deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(240deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(240deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(240 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(270deg 0% 0%)", "rgb(128, 0, 255)", +"hwb(270 0% 0%)", "rgb(128, 0, 255)", +"hwb(270deg 0% 0% / 0)", "rgba(128, 0, 255, 0)", +"hwb(270 0% 0% / 0)", "rgba(128, 0, 255, 0)", +"hwb(270deg 0% 0% / 0.2)", "rgba(128, 0, 255, 0.2)", +"hwb(270 0% 0% / 0.2)", "rgba(128, 0, 255, 0.2)", +"hwb(270deg 0% 0% / 1)", "rgb(128, 0, 255)", +"hwb(270 0% 0% / 1)", "rgb(128, 0, 255)", +"hwb(270deg 0% 12.5%)", "rgb(112, 0, 223)", +"hwb(270 0% 12.5%)", "rgb(112, 0, 223)", +"hwb(270deg 0% 12.5% / 0)", "rgba(112, 0, 223, 0)", +"hwb(270 0% 12.5% / 0)", "rgba(112, 0, 223, 0)", +"hwb(270deg 0% 12.5% / 0.2)", "rgba(112, 0, 223, 0.2)", +"hwb(270 0% 12.5% / 0.2)", "rgba(112, 0, 223, 0.2)", +"hwb(270deg 0% 12.5% / 1)", "rgb(112, 0, 223)", +"hwb(270 0% 12.5% / 1)", "rgb(112, 0, 223)", +"hwb(270deg 0% 25%)", "rgb(96, 0, 191)", +"hwb(270 0% 25%)", "rgb(96, 0, 191)", +"hwb(270deg 0% 25% / 0)", "rgba(96, 0, 191, 0)", +"hwb(270 0% 25% / 0)", "rgba(96, 0, 191, 0)", +"hwb(270deg 0% 25% / 0.2)", "rgba(96, 0, 191, 0.2)", +"hwb(270 0% 25% / 0.2)", "rgba(96, 0, 191, 0.2)", +"hwb(270deg 0% 25% / 1)", "rgb(96, 0, 191)", +"hwb(270 0% 25% / 1)", "rgb(96, 0, 191)", +"hwb(270deg 0% 37.5%)", "rgb(80, 0, 159)", +"hwb(270 0% 37.5%)", "rgb(80, 0, 159)", +"hwb(270deg 0% 37.5% / 0)", "rgba(80, 0, 159, 0)", +"hwb(270 0% 37.5% / 0)", "rgba(80, 0, 159, 0)", +"hwb(270deg 0% 37.5% / 0.2)", "rgba(80, 0, 159, 0.2)", +"hwb(270 0% 37.5% / 0.2)", "rgba(80, 0, 159, 0.2)", +"hwb(270deg 0% 37.5% / 1)", "rgb(80, 0, 159)", +"hwb(270 0% 37.5% / 1)", "rgb(80, 0, 159)", +"hwb(270deg 0% 50%)", "rgb(64, 0, 128)", +"hwb(270 0% 50%)", "rgb(64, 0, 128)", +"hwb(270deg 0% 50% / 0)", "rgba(64, 0, 128, 0)", +"hwb(270 0% 50% / 0)", "rgba(64, 0, 128, 0)", +"hwb(270deg 0% 50% / 0.2)", "rgba(64, 0, 128, 0.2)", +"hwb(270 0% 50% / 0.2)", "rgba(64, 0, 128, 0.2)", +"hwb(270deg 0% 50% / 1)", "rgb(64, 0, 128)", +"hwb(270 0% 50% / 1)", "rgb(64, 0, 128)", +"hwb(270deg 0% 62.5%)", "rgb(48, 0, 96)", +"hwb(270 0% 62.5%)", "rgb(48, 0, 96)", +"hwb(270deg 0% 62.5% / 0)", "rgba(48, 0, 96, 0)", +"hwb(270 0% 62.5% / 0)", "rgba(48, 0, 96, 0)", +"hwb(270deg 0% 62.5% / 0.2)", "rgba(48, 0, 96, 0.2)", +"hwb(270 0% 62.5% / 0.2)", "rgba(48, 0, 96, 0.2)", +"hwb(270deg 0% 62.5% / 1)", "rgb(48, 0, 96)", +"hwb(270 0% 62.5% / 1)", "rgb(48, 0, 96)", +"hwb(270deg 0% 75%)", "rgb(32, 0, 64)", +"hwb(270 0% 75%)", "rgb(32, 0, 64)", +"hwb(270deg 0% 75% / 0)", "rgba(32, 0, 64, 0)", +"hwb(270 0% 75% / 0)", "rgba(32, 0, 64, 0)", +"hwb(270deg 0% 75% / 0.2)", "rgba(32, 0, 64, 0.2)", +"hwb(270 0% 75% / 0.2)", "rgba(32, 0, 64, 0.2)", +"hwb(270deg 0% 75% / 1)", "rgb(32, 0, 64)", +"hwb(270 0% 75% / 1)", "rgb(32, 0, 64)", +"hwb(270deg 0% 87.5%)", "rgb(16, 0, 32)", +"hwb(270 0% 87.5%)", "rgb(16, 0, 32)", +"hwb(270deg 0% 87.5% / 0)", "rgba(16, 0, 32, 0)", +"hwb(270 0% 87.5% / 0)", "rgba(16, 0, 32, 0)", +"hwb(270deg 0% 87.5% / 0.2)", "rgba(16, 0, 32, 0.2)", +"hwb(270 0% 87.5% / 0.2)", "rgba(16, 0, 32, 0.2)", +"hwb(270deg 0% 87.5% / 1)", "rgb(16, 0, 32)", +"hwb(270 0% 87.5% / 1)", "rgb(16, 0, 32)", +"hwb(270deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(270 0% 100%)", "rgb(0, 0, 0)", +"hwb(270deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(270 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(270deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(270 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(270deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(270 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(270deg 12.5% 0%)", "rgb(143, 32, 255)", +"hwb(270 12.5% 0%)", "rgb(143, 32, 255)", +"hwb(270deg 12.5% 0% / 0)", "rgba(143, 32, 255, 0)", +"hwb(270 12.5% 0% / 0)", "rgba(143, 32, 255, 0)", +"hwb(270deg 12.5% 0% / 0.2)", "rgba(143, 32, 255, 0.2)", +"hwb(270 12.5% 0% / 0.2)", "rgba(143, 32, 255, 0.2)", +"hwb(270deg 12.5% 0% / 1)", "rgb(143, 32, 255)", +"hwb(270 12.5% 0% / 1)", "rgb(143, 32, 255)", +"hwb(270deg 12.5% 12.5%)", "rgb(128, 32, 223)", +"hwb(270 12.5% 12.5%)", "rgb(128, 32, 223)", +"hwb(270deg 12.5% 12.5% / 0)", "rgba(128, 32, 223, 0)", +"hwb(270 12.5% 12.5% / 0)", "rgba(128, 32, 223, 0)", +"hwb(270deg 12.5% 12.5% / 0.2)", "rgba(128, 32, 223, 0.2)", +"hwb(270 12.5% 12.5% / 0.2)", "rgba(128, 32, 223, 0.2)", +"hwb(270deg 12.5% 12.5% / 1)", "rgb(128, 32, 223)", +"hwb(270 12.5% 12.5% / 1)", "rgb(128, 32, 223)", +"hwb(270deg 12.5% 25%)", "rgb(112, 32, 191)", +"hwb(270 12.5% 25%)", "rgb(112, 32, 191)", +"hwb(270deg 12.5% 25% / 0)", "rgba(112, 32, 191, 0)", +"hwb(270 12.5% 25% / 0)", "rgba(112, 32, 191, 0)", +"hwb(270deg 12.5% 25% / 0.2)", "rgba(112, 32, 191, 0.2)", +"hwb(270 12.5% 25% / 0.2)", "rgba(112, 32, 191, 0.2)", +"hwb(270deg 12.5% 25% / 1)", "rgb(112, 32, 191)", +"hwb(270 12.5% 25% / 1)", "rgb(112, 32, 191)", +"hwb(270deg 12.5% 37.5%)", "rgb(96, 32, 159)", +"hwb(270 12.5% 37.5%)", "rgb(96, 32, 159)", +"hwb(270deg 12.5% 37.5% / 0)", "rgba(96, 32, 159, 0)", +"hwb(270 12.5% 37.5% / 0)", "rgba(96, 32, 159, 0)", +"hwb(270deg 12.5% 37.5% / 0.2)", "rgba(96, 32, 159, 0.2)", +"hwb(270 12.5% 37.5% / 0.2)", "rgba(96, 32, 159, 0.2)", +"hwb(270deg 12.5% 37.5% / 1)", "rgb(96, 32, 159)", +"hwb(270 12.5% 37.5% / 1)", "rgb(96, 32, 159)", +"hwb(270deg 12.5% 50%)", "rgb(80, 32, 128)", +"hwb(270 12.5% 50%)", "rgb(80, 32, 128)", +"hwb(270deg 12.5% 50% / 0)", "rgba(80, 32, 128, 0)", +"hwb(270 12.5% 50% / 0)", "rgba(80, 32, 128, 0)", +"hwb(270deg 12.5% 50% / 0.2)", "rgba(80, 32, 128, 0.2)", +"hwb(270 12.5% 50% / 0.2)", "rgba(80, 32, 128, 0.2)", +"hwb(270deg 12.5% 50% / 1)", "rgb(80, 32, 128)", +"hwb(270 12.5% 50% / 1)", "rgb(80, 32, 128)", +"hwb(270deg 12.5% 62.5%)", "rgb(64, 32, 96)", +"hwb(270 12.5% 62.5%)", "rgb(64, 32, 96)", +"hwb(270deg 12.5% 62.5% / 0)", "rgba(64, 32, 96, 0)", +"hwb(270 12.5% 62.5% / 0)", "rgba(64, 32, 96, 0)", +"hwb(270deg 12.5% 62.5% / 0.2)", "rgba(64, 32, 96, 0.2)", +"hwb(270 12.5% 62.5% / 0.2)", "rgba(64, 32, 96, 0.2)", +"hwb(270deg 12.5% 62.5% / 1)", "rgb(64, 32, 96)", +"hwb(270 12.5% 62.5% / 1)", "rgb(64, 32, 96)", +"hwb(270deg 12.5% 75%)", "rgb(48, 32, 64)", +"hwb(270 12.5% 75%)", "rgb(48, 32, 64)", +"hwb(270deg 12.5% 75% / 0)", "rgba(48, 32, 64, 0)", +"hwb(270 12.5% 75% / 0)", "rgba(48, 32, 64, 0)", +"hwb(270deg 12.5% 75% / 0.2)", "rgba(48, 32, 64, 0.2)", +"hwb(270 12.5% 75% / 0.2)", "rgba(48, 32, 64, 0.2)", +"hwb(270deg 12.5% 75% / 1)", "rgb(48, 32, 64)", +"hwb(270 12.5% 75% / 1)", "rgb(48, 32, 64)", +"hwb(270deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(270 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(270deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(270 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(270deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(270 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(270deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(270 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(270deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(270 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(270deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(270 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(270deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(270 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(270deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(270 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(270deg 25% 0%)", "rgb(159, 64, 255)", +"hwb(270 25% 0%)", "rgb(159, 64, 255)", +"hwb(270deg 25% 0% / 0)", "rgba(159, 64, 255, 0)", +"hwb(270 25% 0% / 0)", "rgba(159, 64, 255, 0)", +"hwb(270deg 25% 0% / 0.2)", "rgba(159, 64, 255, 0.2)", +"hwb(270 25% 0% / 0.2)", "rgba(159, 64, 255, 0.2)", +"hwb(270deg 25% 0% / 1)", "rgb(159, 64, 255)", +"hwb(270 25% 0% / 1)", "rgb(159, 64, 255)", +"hwb(270deg 25% 12.5%)", "rgb(143, 64, 223)", +"hwb(270 25% 12.5%)", "rgb(143, 64, 223)", +"hwb(270deg 25% 12.5% / 0)", "rgba(143, 64, 223, 0)", +"hwb(270 25% 12.5% / 0)", "rgba(143, 64, 223, 0)", +"hwb(270deg 25% 12.5% / 0.2)", "rgba(143, 64, 223, 0.2)", +"hwb(270 25% 12.5% / 0.2)", "rgba(143, 64, 223, 0.2)", +"hwb(270deg 25% 12.5% / 1)", "rgb(143, 64, 223)", +"hwb(270 25% 12.5% / 1)", "rgb(143, 64, 223)", +"hwb(270deg 25% 25%)", "rgb(128, 64, 191)", +"hwb(270 25% 25%)", "rgb(128, 64, 191)", +"hwb(270deg 25% 25% / 0)", "rgba(128, 64, 191, 0)", +"hwb(270 25% 25% / 0)", "rgba(128, 64, 191, 0)", +"hwb(270deg 25% 25% / 0.2)", "rgba(128, 64, 191, 0.2)", +"hwb(270 25% 25% / 0.2)", "rgba(128, 64, 191, 0.2)", +"hwb(270deg 25% 25% / 1)", "rgb(128, 64, 191)", +"hwb(270 25% 25% / 1)", "rgb(128, 64, 191)", +"hwb(270deg 25% 37.5%)", "rgb(112, 64, 159)", +"hwb(270 25% 37.5%)", "rgb(112, 64, 159)", +"hwb(270deg 25% 37.5% / 0)", "rgba(112, 64, 159, 0)", +"hwb(270 25% 37.5% / 0)", "rgba(112, 64, 159, 0)", +"hwb(270deg 25% 37.5% / 0.2)", "rgba(112, 64, 159, 0.2)", +"hwb(270 25% 37.5% / 0.2)", "rgba(112, 64, 159, 0.2)", +"hwb(270deg 25% 37.5% / 1)", "rgb(112, 64, 159)", +"hwb(270 25% 37.5% / 1)", "rgb(112, 64, 159)", +"hwb(270deg 25% 50%)", "rgb(96, 64, 128)", +"hwb(270 25% 50%)", "rgb(96, 64, 128)", +"hwb(270deg 25% 50% / 0)", "rgba(96, 64, 128, 0)", +"hwb(270 25% 50% / 0)", "rgba(96, 64, 128, 0)", +"hwb(270deg 25% 50% / 0.2)", "rgba(96, 64, 128, 0.2)", +"hwb(270 25% 50% / 0.2)", "rgba(96, 64, 128, 0.2)", +"hwb(270deg 25% 50% / 1)", "rgb(96, 64, 128)", +"hwb(270 25% 50% / 1)", "rgb(96, 64, 128)", +"hwb(270deg 25% 62.5%)", "rgb(80, 64, 96)", +"hwb(270 25% 62.5%)", "rgb(80, 64, 96)", +"hwb(270deg 25% 62.5% / 0)", "rgba(80, 64, 96, 0)", +"hwb(270 25% 62.5% / 0)", "rgba(80, 64, 96, 0)", +"hwb(270deg 25% 62.5% / 0.2)", "rgba(80, 64, 96, 0.2)", +"hwb(270 25% 62.5% / 0.2)", "rgba(80, 64, 96, 0.2)", +"hwb(270deg 25% 62.5% / 1)", "rgb(80, 64, 96)", +"hwb(270 25% 62.5% / 1)", "rgb(80, 64, 96)", +"hwb(270deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(270 25% 75%)", "rgb(64, 64, 64)", +"hwb(270deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(270 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(270deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(270 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(270deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(270 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(270deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(270 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(270deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(270 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(270deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(270 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(270deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(270 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(270deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(270 25% 100%)", "rgb(51, 51, 51)", +"hwb(270deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(270 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(270deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(270 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(270deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(270 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(270deg 37.5% 0%)", "rgb(175, 96, 255)", +"hwb(270 37.5% 0%)", "rgb(175, 96, 255)", +"hwb(270deg 37.5% 0% / 0)", "rgba(175, 96, 255, 0)", +"hwb(270 37.5% 0% / 0)", "rgba(175, 96, 255, 0)", +"hwb(270deg 37.5% 0% / 0.2)", "rgba(175, 96, 255, 0.2)", +"hwb(270 37.5% 0% / 0.2)", "rgba(175, 96, 255, 0.2)", +"hwb(270deg 37.5% 0% / 1)", "rgb(175, 96, 255)", +"hwb(270 37.5% 0% / 1)", "rgb(175, 96, 255)", +"hwb(270deg 37.5% 12.5%)", "rgb(159, 96, 223)", +"hwb(270 37.5% 12.5%)", "rgb(159, 96, 223)", +"hwb(270deg 37.5% 12.5% / 0)", "rgba(159, 96, 223, 0)", +"hwb(270 37.5% 12.5% / 0)", "rgba(159, 96, 223, 0)", +"hwb(270deg 37.5% 12.5% / 0.2)", "rgba(159, 96, 223, 0.2)", +"hwb(270 37.5% 12.5% / 0.2)", "rgba(159, 96, 223, 0.2)", +"hwb(270deg 37.5% 12.5% / 1)", "rgb(159, 96, 223)", +"hwb(270 37.5% 12.5% / 1)", "rgb(159, 96, 223)", +"hwb(270deg 37.5% 25%)", "rgb(143, 96, 191)", +"hwb(270 37.5% 25%)", "rgb(143, 96, 191)", +"hwb(270deg 37.5% 25% / 0)", "rgba(143, 96, 191, 0)", +"hwb(270 37.5% 25% / 0)", "rgba(143, 96, 191, 0)", +"hwb(270deg 37.5% 25% / 0.2)", "rgba(143, 96, 191, 0.2)", +"hwb(270 37.5% 25% / 0.2)", "rgba(143, 96, 191, 0.2)", +"hwb(270deg 37.5% 25% / 1)", "rgb(143, 96, 191)", +"hwb(270 37.5% 25% / 1)", "rgb(143, 96, 191)", +"hwb(270deg 37.5% 37.5%)", "rgb(128, 96, 159)", +"hwb(270 37.5% 37.5%)", "rgb(128, 96, 159)", +"hwb(270deg 37.5% 37.5% / 0)", "rgba(128, 96, 159, 0)", +"hwb(270 37.5% 37.5% / 0)", "rgba(128, 96, 159, 0)", +"hwb(270deg 37.5% 37.5% / 0.2)", "rgba(128, 96, 159, 0.2)", +"hwb(270 37.5% 37.5% / 0.2)", "rgba(128, 96, 159, 0.2)", +"hwb(270deg 37.5% 37.5% / 1)", "rgb(128, 96, 159)", +"hwb(270 37.5% 37.5% / 1)", "rgb(128, 96, 159)", +"hwb(270deg 37.5% 50%)", "rgb(112, 96, 128)", +"hwb(270 37.5% 50%)", "rgb(112, 96, 128)", +"hwb(270deg 37.5% 50% / 0)", "rgba(112, 96, 128, 0)", +"hwb(270 37.5% 50% / 0)", "rgba(112, 96, 128, 0)", +"hwb(270deg 37.5% 50% / 0.2)", "rgba(112, 96, 128, 0.2)", +"hwb(270 37.5% 50% / 0.2)", "rgba(112, 96, 128, 0.2)", +"hwb(270deg 37.5% 50% / 1)", "rgb(112, 96, 128)", +"hwb(270 37.5% 50% / 1)", "rgb(112, 96, 128)", +"hwb(270deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(270 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(270deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(270 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(270deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(270 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(270deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(270 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(270deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(270 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(270deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(270 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(270deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(270 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(270deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(270 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(270deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(270 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(270deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(270 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(270deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(270 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(270deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(270 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(270deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(270 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(270deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(270 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(270deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(270 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(270deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(270 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(270deg 50% 0%)", "rgb(191, 128, 255)", +"hwb(270 50% 0%)", "rgb(191, 128, 255)", +"hwb(270deg 50% 0% / 0)", "rgba(191, 128, 255, 0)", +"hwb(270 50% 0% / 0)", "rgba(191, 128, 255, 0)", +"hwb(270deg 50% 0% / 0.2)", "rgba(191, 128, 255, 0.2)", +"hwb(270 50% 0% / 0.2)", "rgba(191, 128, 255, 0.2)", +"hwb(270deg 50% 0% / 1)", "rgb(191, 128, 255)", +"hwb(270 50% 0% / 1)", "rgb(191, 128, 255)", +"hwb(270deg 50% 12.5%)", "rgb(175, 128, 223)", +"hwb(270 50% 12.5%)", "rgb(175, 128, 223)", +"hwb(270deg 50% 12.5% / 0)", "rgba(175, 128, 223, 0)", +"hwb(270 50% 12.5% / 0)", "rgba(175, 128, 223, 0)", +"hwb(270deg 50% 12.5% / 0.2)", "rgba(175, 128, 223, 0.2)", +"hwb(270 50% 12.5% / 0.2)", "rgba(175, 128, 223, 0.2)", +"hwb(270deg 50% 12.5% / 1)", "rgb(175, 128, 223)", +"hwb(270 50% 12.5% / 1)", "rgb(175, 128, 223)", +"hwb(270deg 50% 25%)", "rgb(159, 128, 191)", +"hwb(270 50% 25%)", "rgb(159, 128, 191)", +"hwb(270deg 50% 25% / 0)", "rgba(159, 128, 191, 0)", +"hwb(270 50% 25% / 0)", "rgba(159, 128, 191, 0)", +"hwb(270deg 50% 25% / 0.2)", "rgba(159, 128, 191, 0.2)", +"hwb(270 50% 25% / 0.2)", "rgba(159, 128, 191, 0.2)", +"hwb(270deg 50% 25% / 1)", "rgb(159, 128, 191)", +"hwb(270 50% 25% / 1)", "rgb(159, 128, 191)", +"hwb(270deg 50% 37.5%)", "rgb(143, 128, 159)", +"hwb(270 50% 37.5%)", "rgb(143, 128, 159)", +"hwb(270deg 50% 37.5% / 0)", "rgba(143, 128, 159, 0)", +"hwb(270 50% 37.5% / 0)", "rgba(143, 128, 159, 0)", +"hwb(270deg 50% 37.5% / 0.2)", "rgba(143, 128, 159, 0.2)", +"hwb(270 50% 37.5% / 0.2)", "rgba(143, 128, 159, 0.2)", +"hwb(270deg 50% 37.5% / 1)", "rgb(143, 128, 159)", +"hwb(270 50% 37.5% / 1)", "rgb(143, 128, 159)", +"hwb(270deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(270 50% 50%)", "rgb(128, 128, 128)", +"hwb(270deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(270 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(270deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(270 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(270deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(270 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(270deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(270 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(270deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(270 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(270deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(270 50% 75%)", "rgb(102, 102, 102)", +"hwb(270deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(270 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(270deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(270 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(270deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(270 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(270deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(270 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(270deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(270 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(270deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(270 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(270deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(270 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(270deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(270 50% 100%)", "rgb(85, 85, 85)", +"hwb(270deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(270 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(270deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(270 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(270deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(270 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(270deg 62.5% 0%)", "rgb(207, 159, 255)", +"hwb(270 62.5% 0%)", "rgb(207, 159, 255)", +"hwb(270deg 62.5% 0% / 0)", "rgba(207, 159, 255, 0)", +"hwb(270 62.5% 0% / 0)", "rgba(207, 159, 255, 0)", +"hwb(270deg 62.5% 0% / 0.2)", "rgba(207, 159, 255, 0.2)", +"hwb(270 62.5% 0% / 0.2)", "rgba(207, 159, 255, 0.2)", +"hwb(270deg 62.5% 0% / 1)", "rgb(207, 159, 255)", +"hwb(270 62.5% 0% / 1)", "rgb(207, 159, 255)", +"hwb(270deg 62.5% 12.5%)", "rgb(191, 159, 223)", +"hwb(270 62.5% 12.5%)", "rgb(191, 159, 223)", +"hwb(270deg 62.5% 12.5% / 0)", "rgba(191, 159, 223, 0)", +"hwb(270 62.5% 12.5% / 0)", "rgba(191, 159, 223, 0)", +"hwb(270deg 62.5% 12.5% / 0.2)", "rgba(191, 159, 223, 0.2)", +"hwb(270 62.5% 12.5% / 0.2)", "rgba(191, 159, 223, 0.2)", +"hwb(270deg 62.5% 12.5% / 1)", "rgb(191, 159, 223)", +"hwb(270 62.5% 12.5% / 1)", "rgb(191, 159, 223)", +"hwb(270deg 62.5% 25%)", "rgb(175, 159, 191)", +"hwb(270 62.5% 25%)", "rgb(175, 159, 191)", +"hwb(270deg 62.5% 25% / 0)", "rgba(175, 159, 191, 0)", +"hwb(270 62.5% 25% / 0)", "rgba(175, 159, 191, 0)", +"hwb(270deg 62.5% 25% / 0.2)", "rgba(175, 159, 191, 0.2)", +"hwb(270 62.5% 25% / 0.2)", "rgba(175, 159, 191, 0.2)", +"hwb(270deg 62.5% 25% / 1)", "rgb(175, 159, 191)", +"hwb(270 62.5% 25% / 1)", "rgb(175, 159, 191)", +"hwb(270deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(270 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(270deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(270 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(270deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(270 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(270deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(270 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(270deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(270 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(270deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(270 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(270deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(270 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(270deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(270 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(270deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(270 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(270deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(270 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(270deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(270 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(270deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(270 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(270deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(270 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(270deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(270 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(270deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(270 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(270deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(270 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(270deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(270 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(270deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(270 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(270deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(270 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(270deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(270 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(270deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(270 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(270deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(270 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(270deg 75% 0%)", "rgb(223, 191, 255)", +"hwb(270 75% 0%)", "rgb(223, 191, 255)", +"hwb(270deg 75% 0% / 0)", "rgba(223, 191, 255, 0)", +"hwb(270 75% 0% / 0)", "rgba(223, 191, 255, 0)", +"hwb(270deg 75% 0% / 0.2)", "rgba(223, 191, 255, 0.2)", +"hwb(270 75% 0% / 0.2)", "rgba(223, 191, 255, 0.2)", +"hwb(270deg 75% 0% / 1)", "rgb(223, 191, 255)", +"hwb(270 75% 0% / 1)", "rgb(223, 191, 255)", +"hwb(270deg 75% 12.5%)", "rgb(207, 191, 223)", +"hwb(270 75% 12.5%)", "rgb(207, 191, 223)", +"hwb(270deg 75% 12.5% / 0)", "rgba(207, 191, 223, 0)", +"hwb(270 75% 12.5% / 0)", "rgba(207, 191, 223, 0)", +"hwb(270deg 75% 12.5% / 0.2)", "rgba(207, 191, 223, 0.2)", +"hwb(270 75% 12.5% / 0.2)", "rgba(207, 191, 223, 0.2)", +"hwb(270deg 75% 12.5% / 1)", "rgb(207, 191, 223)", +"hwb(270 75% 12.5% / 1)", "rgb(207, 191, 223)", +"hwb(270deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(270 75% 25%)", "rgb(191, 191, 191)", +"hwb(270deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(270 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(270deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(270 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(270deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(270 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(270deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(270 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(270deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(270 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(270deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(270 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(270deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(270 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(270deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(270 75% 50%)", "rgb(153, 153, 153)", +"hwb(270deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(270 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(270deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(270 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(270deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(270 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(270deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(270 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(270deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(270 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(270deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(270 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(270deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(270 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(270deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(270 75% 75%)", "rgb(128, 128, 128)", +"hwb(270deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(270 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(270deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(270 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(270deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(270 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(270deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(270 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(270deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(270 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(270deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(270 75% 100%)", "rgb(109, 109, 109)", +"hwb(270deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(270 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(270deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(270 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(270deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(270 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(270deg 87.5% 0%)", "rgb(239, 223, 255)", +"hwb(270 87.5% 0%)", "rgb(239, 223, 255)", +"hwb(270deg 87.5% 0% / 0)", "rgba(239, 223, 255, 0)", +"hwb(270 87.5% 0% / 0)", "rgba(239, 223, 255, 0)", +"hwb(270deg 87.5% 0% / 0.2)", "rgba(239, 223, 255, 0.2)", +"hwb(270 87.5% 0% / 0.2)", "rgba(239, 223, 255, 0.2)", +"hwb(270deg 87.5% 0% / 1)", "rgb(239, 223, 255)", +"hwb(270 87.5% 0% / 1)", "rgb(239, 223, 255)", +"hwb(270deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(270 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(270deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(270 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(270deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(270 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(270deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(270 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(270deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(270 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(270deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(270 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(270deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(270 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(270deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(270 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(270deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(270 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(270deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(270 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(270deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(270 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(270deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(270 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(270deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(270 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(270deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(270 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(270deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(270 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(270deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(270 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(270deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(270 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(270deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(270 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(270deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(270 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(270deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(270 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(270deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(270 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(270deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(270 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(270deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(270 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(270deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(270 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(270deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(270 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(270deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(270 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(270deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(270 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(270deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(270 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(270deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(270 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(270deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(270 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(270deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(270 100% 0%)", "rgb(255, 255, 255)", +"hwb(270deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(270 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(270deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(270 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(270deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(270 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(270deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(270 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(270deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(270 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(270deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(270 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(270deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(270 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(270deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(270 100% 25%)", "rgb(204, 204, 204)", +"hwb(270deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(270 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(270deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(270 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(270deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(270 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(270deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(270 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(270deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(270 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(270deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(270 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(270deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(270 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(270deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(270 100% 50%)", "rgb(170, 170, 170)", +"hwb(270deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(270 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(270deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(270 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(270deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(270 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(270deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(270 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(270deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(270 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(270deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(270 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(270deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(270 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(270deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(270 100% 75%)", "rgb(146, 146, 146)", +"hwb(270deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(270 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(270deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(270 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(270deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(270 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(270deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(270 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(270deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(270 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(270deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(270 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(270deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(270 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(270deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(270 100% 100%)", "rgb(128, 128, 128)", +"hwb(270deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(270deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(270deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(270 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(300deg 0% 0%)", "rgb(255, 0, 255)", +"hwb(300 0% 0%)", "rgb(255, 0, 255)", +"hwb(300deg 0% 0% / 0)", "rgba(255, 0, 255, 0)", +"hwb(300 0% 0% / 0)", "rgba(255, 0, 255, 0)", +"hwb(300deg 0% 0% / 0.2)", "rgba(255, 0, 255, 0.2)", +"hwb(300 0% 0% / 0.2)", "rgba(255, 0, 255, 0.2)", +"hwb(300deg 0% 0% / 1)", "rgb(255, 0, 255)", +"hwb(300 0% 0% / 1)", "rgb(255, 0, 255)", +"hwb(300deg 0% 12.5%)", "rgb(223, 0, 223)", +"hwb(300 0% 12.5%)", "rgb(223, 0, 223)", +"hwb(300deg 0% 12.5% / 0)", "rgba(223, 0, 223, 0)", +"hwb(300 0% 12.5% / 0)", "rgba(223, 0, 223, 0)", +"hwb(300deg 0% 12.5% / 0.2)", "rgba(223, 0, 223, 0.2)", +"hwb(300 0% 12.5% / 0.2)", "rgba(223, 0, 223, 0.2)", +"hwb(300deg 0% 12.5% / 1)", "rgb(223, 0, 223)", +"hwb(300 0% 12.5% / 1)", "rgb(223, 0, 223)", +"hwb(300deg 0% 25%)", "rgb(191, 0, 191)", +"hwb(300 0% 25%)", "rgb(191, 0, 191)", +"hwb(300deg 0% 25% / 0)", "rgba(191, 0, 191, 0)", +"hwb(300 0% 25% / 0)", "rgba(191, 0, 191, 0)", +"hwb(300deg 0% 25% / 0.2)", "rgba(191, 0, 191, 0.2)", +"hwb(300 0% 25% / 0.2)", "rgba(191, 0, 191, 0.2)", +"hwb(300deg 0% 25% / 1)", "rgb(191, 0, 191)", +"hwb(300 0% 25% / 1)", "rgb(191, 0, 191)", +"hwb(300deg 0% 37.5%)", "rgb(159, 0, 159)", +"hwb(300 0% 37.5%)", "rgb(159, 0, 159)", +"hwb(300deg 0% 37.5% / 0)", "rgba(159, 0, 159, 0)", +"hwb(300 0% 37.5% / 0)", "rgba(159, 0, 159, 0)", +"hwb(300deg 0% 37.5% / 0.2)", "rgba(159, 0, 159, 0.2)", +"hwb(300 0% 37.5% / 0.2)", "rgba(159, 0, 159, 0.2)", +"hwb(300deg 0% 37.5% / 1)", "rgb(159, 0, 159)", +"hwb(300 0% 37.5% / 1)", "rgb(159, 0, 159)", +"hwb(300deg 0% 50%)", "rgb(128, 0, 128)", +"hwb(300 0% 50%)", "rgb(128, 0, 128)", +"hwb(300deg 0% 50% / 0)", "rgba(128, 0, 128, 0)", +"hwb(300 0% 50% / 0)", "rgba(128, 0, 128, 0)", +"hwb(300deg 0% 50% / 0.2)", "rgba(128, 0, 128, 0.2)", +"hwb(300 0% 50% / 0.2)", "rgba(128, 0, 128, 0.2)", +"hwb(300deg 0% 50% / 1)", "rgb(128, 0, 128)", +"hwb(300 0% 50% / 1)", "rgb(128, 0, 128)", +"hwb(300deg 0% 62.5%)", "rgb(96, 0, 96)", +"hwb(300 0% 62.5%)", "rgb(96, 0, 96)", +"hwb(300deg 0% 62.5% / 0)", "rgba(96, 0, 96, 0)", +"hwb(300 0% 62.5% / 0)", "rgba(96, 0, 96, 0)", +"hwb(300deg 0% 62.5% / 0.2)", "rgba(96, 0, 96, 0.2)", +"hwb(300 0% 62.5% / 0.2)", "rgba(96, 0, 96, 0.2)", +"hwb(300deg 0% 62.5% / 1)", "rgb(96, 0, 96)", +"hwb(300 0% 62.5% / 1)", "rgb(96, 0, 96)", +"hwb(300deg 0% 75%)", "rgb(64, 0, 64)", +"hwb(300 0% 75%)", "rgb(64, 0, 64)", +"hwb(300deg 0% 75% / 0)", "rgba(64, 0, 64, 0)", +"hwb(300 0% 75% / 0)", "rgba(64, 0, 64, 0)", +"hwb(300deg 0% 75% / 0.2)", "rgba(64, 0, 64, 0.2)", +"hwb(300 0% 75% / 0.2)", "rgba(64, 0, 64, 0.2)", +"hwb(300deg 0% 75% / 1)", "rgb(64, 0, 64)", +"hwb(300 0% 75% / 1)", "rgb(64, 0, 64)", +"hwb(300deg 0% 87.5%)", "rgb(32, 0, 32)", +"hwb(300 0% 87.5%)", "rgb(32, 0, 32)", +"hwb(300deg 0% 87.5% / 0)", "rgba(32, 0, 32, 0)", +"hwb(300 0% 87.5% / 0)", "rgba(32, 0, 32, 0)", +"hwb(300deg 0% 87.5% / 0.2)", "rgba(32, 0, 32, 0.2)", +"hwb(300 0% 87.5% / 0.2)", "rgba(32, 0, 32, 0.2)", +"hwb(300deg 0% 87.5% / 1)", "rgb(32, 0, 32)", +"hwb(300 0% 87.5% / 1)", "rgb(32, 0, 32)", +"hwb(300deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(300 0% 100%)", "rgb(0, 0, 0)", +"hwb(300deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(300 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(300deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(300 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(300deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(300 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(300deg 12.5% 0%)", "rgb(255, 32, 255)", +"hwb(300 12.5% 0%)", "rgb(255, 32, 255)", +"hwb(300deg 12.5% 0% / 0)", "rgba(255, 32, 255, 0)", +"hwb(300 12.5% 0% / 0)", "rgba(255, 32, 255, 0)", +"hwb(300deg 12.5% 0% / 0.2)", "rgba(255, 32, 255, 0.2)", +"hwb(300 12.5% 0% / 0.2)", "rgba(255, 32, 255, 0.2)", +"hwb(300deg 12.5% 0% / 1)", "rgb(255, 32, 255)", +"hwb(300 12.5% 0% / 1)", "rgb(255, 32, 255)", +"hwb(300deg 12.5% 12.5%)", "rgb(223, 32, 223)", +"hwb(300 12.5% 12.5%)", "rgb(223, 32, 223)", +"hwb(300deg 12.5% 12.5% / 0)", "rgba(223, 32, 223, 0)", +"hwb(300 12.5% 12.5% / 0)", "rgba(223, 32, 223, 0)", +"hwb(300deg 12.5% 12.5% / 0.2)", "rgba(223, 32, 223, 0.2)", +"hwb(300 12.5% 12.5% / 0.2)", "rgba(223, 32, 223, 0.2)", +"hwb(300deg 12.5% 12.5% / 1)", "rgb(223, 32, 223)", +"hwb(300 12.5% 12.5% / 1)", "rgb(223, 32, 223)", +"hwb(300deg 12.5% 25%)", "rgb(191, 32, 191)", +"hwb(300 12.5% 25%)", "rgb(191, 32, 191)", +"hwb(300deg 12.5% 25% / 0)", "rgba(191, 32, 191, 0)", +"hwb(300 12.5% 25% / 0)", "rgba(191, 32, 191, 0)", +"hwb(300deg 12.5% 25% / 0.2)", "rgba(191, 32, 191, 0.2)", +"hwb(300 12.5% 25% / 0.2)", "rgba(191, 32, 191, 0.2)", +"hwb(300deg 12.5% 25% / 1)", "rgb(191, 32, 191)", +"hwb(300 12.5% 25% / 1)", "rgb(191, 32, 191)", +"hwb(300deg 12.5% 37.5%)", "rgb(159, 32, 159)", +"hwb(300 12.5% 37.5%)", "rgb(159, 32, 159)", +"hwb(300deg 12.5% 37.5% / 0)", "rgba(159, 32, 159, 0)", +"hwb(300 12.5% 37.5% / 0)", "rgba(159, 32, 159, 0)", +"hwb(300deg 12.5% 37.5% / 0.2)", "rgba(159, 32, 159, 0.2)", +"hwb(300 12.5% 37.5% / 0.2)", "rgba(159, 32, 159, 0.2)", +"hwb(300deg 12.5% 37.5% / 1)", "rgb(159, 32, 159)", +"hwb(300 12.5% 37.5% / 1)", "rgb(159, 32, 159)", +"hwb(300deg 12.5% 50%)", "rgb(128, 32, 128)", +"hwb(300 12.5% 50%)", "rgb(128, 32, 128)", +"hwb(300deg 12.5% 50% / 0)", "rgba(128, 32, 128, 0)", +"hwb(300 12.5% 50% / 0)", "rgba(128, 32, 128, 0)", +"hwb(300deg 12.5% 50% / 0.2)", "rgba(128, 32, 128, 0.2)", +"hwb(300 12.5% 50% / 0.2)", "rgba(128, 32, 128, 0.2)", +"hwb(300deg 12.5% 50% / 1)", "rgb(128, 32, 128)", +"hwb(300 12.5% 50% / 1)", "rgb(128, 32, 128)", +"hwb(300deg 12.5% 62.5%)", "rgb(96, 32, 96)", +"hwb(300 12.5% 62.5%)", "rgb(96, 32, 96)", +"hwb(300deg 12.5% 62.5% / 0)", "rgba(96, 32, 96, 0)", +"hwb(300 12.5% 62.5% / 0)", "rgba(96, 32, 96, 0)", +"hwb(300deg 12.5% 62.5% / 0.2)", "rgba(96, 32, 96, 0.2)", +"hwb(300 12.5% 62.5% / 0.2)", "rgba(96, 32, 96, 0.2)", +"hwb(300deg 12.5% 62.5% / 1)", "rgb(96, 32, 96)", +"hwb(300 12.5% 62.5% / 1)", "rgb(96, 32, 96)", +"hwb(300deg 12.5% 75%)", "rgb(64, 32, 64)", +"hwb(300 12.5% 75%)", "rgb(64, 32, 64)", +"hwb(300deg 12.5% 75% / 0)", "rgba(64, 32, 64, 0)", +"hwb(300 12.5% 75% / 0)", "rgba(64, 32, 64, 0)", +"hwb(300deg 12.5% 75% / 0.2)", "rgba(64, 32, 64, 0.2)", +"hwb(300 12.5% 75% / 0.2)", "rgba(64, 32, 64, 0.2)", +"hwb(300deg 12.5% 75% / 1)", "rgb(64, 32, 64)", +"hwb(300 12.5% 75% / 1)", "rgb(64, 32, 64)", +"hwb(300deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(300 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(300deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(300 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(300deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(300 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(300deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(300 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(300deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(300 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(300deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(300 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(300deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(300 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(300deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(300 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(300deg 25% 0%)", "rgb(255, 64, 255)", +"hwb(300 25% 0%)", "rgb(255, 64, 255)", +"hwb(300deg 25% 0% / 0)", "rgba(255, 64, 255, 0)", +"hwb(300 25% 0% / 0)", "rgba(255, 64, 255, 0)", +"hwb(300deg 25% 0% / 0.2)", "rgba(255, 64, 255, 0.2)", +"hwb(300 25% 0% / 0.2)", "rgba(255, 64, 255, 0.2)", +"hwb(300deg 25% 0% / 1)", "rgb(255, 64, 255)", +"hwb(300 25% 0% / 1)", "rgb(255, 64, 255)", +"hwb(300deg 25% 12.5%)", "rgb(223, 64, 223)", +"hwb(300 25% 12.5%)", "rgb(223, 64, 223)", +"hwb(300deg 25% 12.5% / 0)", "rgba(223, 64, 223, 0)", +"hwb(300 25% 12.5% / 0)", "rgba(223, 64, 223, 0)", +"hwb(300deg 25% 12.5% / 0.2)", "rgba(223, 64, 223, 0.2)", +"hwb(300 25% 12.5% / 0.2)", "rgba(223, 64, 223, 0.2)", +"hwb(300deg 25% 12.5% / 1)", "rgb(223, 64, 223)", +"hwb(300 25% 12.5% / 1)", "rgb(223, 64, 223)", +"hwb(300deg 25% 25%)", "rgb(191, 64, 191)", +"hwb(300 25% 25%)", "rgb(191, 64, 191)", +"hwb(300deg 25% 25% / 0)", "rgba(191, 64, 191, 0)", +"hwb(300 25% 25% / 0)", "rgba(191, 64, 191, 0)", +"hwb(300deg 25% 25% / 0.2)", "rgba(191, 64, 191, 0.2)", +"hwb(300 25% 25% / 0.2)", "rgba(191, 64, 191, 0.2)", +"hwb(300deg 25% 25% / 1)", "rgb(191, 64, 191)", +"hwb(300 25% 25% / 1)", "rgb(191, 64, 191)", +"hwb(300deg 25% 37.5%)", "rgb(159, 64, 159)", +"hwb(300 25% 37.5%)", "rgb(159, 64, 159)", +"hwb(300deg 25% 37.5% / 0)", "rgba(159, 64, 159, 0)", +"hwb(300 25% 37.5% / 0)", "rgba(159, 64, 159, 0)", +"hwb(300deg 25% 37.5% / 0.2)", "rgba(159, 64, 159, 0.2)", +"hwb(300 25% 37.5% / 0.2)", "rgba(159, 64, 159, 0.2)", +"hwb(300deg 25% 37.5% / 1)", "rgb(159, 64, 159)", +"hwb(300 25% 37.5% / 1)", "rgb(159, 64, 159)", +"hwb(300deg 25% 50%)", "rgb(128, 64, 128)", +"hwb(300 25% 50%)", "rgb(128, 64, 128)", +"hwb(300deg 25% 50% / 0)", "rgba(128, 64, 128, 0)", +"hwb(300 25% 50% / 0)", "rgba(128, 64, 128, 0)", +"hwb(300deg 25% 50% / 0.2)", "rgba(128, 64, 128, 0.2)", +"hwb(300 25% 50% / 0.2)", "rgba(128, 64, 128, 0.2)", +"hwb(300deg 25% 50% / 1)", "rgb(128, 64, 128)", +"hwb(300 25% 50% / 1)", "rgb(128, 64, 128)", +"hwb(300deg 25% 62.5%)", "rgb(96, 64, 96)", +"hwb(300 25% 62.5%)", "rgb(96, 64, 96)", +"hwb(300deg 25% 62.5% / 0)", "rgba(96, 64, 96, 0)", +"hwb(300 25% 62.5% / 0)", "rgba(96, 64, 96, 0)", +"hwb(300deg 25% 62.5% / 0.2)", "rgba(96, 64, 96, 0.2)", +"hwb(300 25% 62.5% / 0.2)", "rgba(96, 64, 96, 0.2)", +"hwb(300deg 25% 62.5% / 1)", "rgb(96, 64, 96)", +"hwb(300 25% 62.5% / 1)", "rgb(96, 64, 96)", +"hwb(300deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(300 25% 75%)", "rgb(64, 64, 64)", +"hwb(300deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(300 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(300deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(300 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(300deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(300 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(300deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(300 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(300deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(300 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(300deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(300 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(300deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(300 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(300deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(300 25% 100%)", "rgb(51, 51, 51)", +"hwb(300deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(300 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(300deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(300 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(300deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(300 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(300deg 37.5% 0%)", "rgb(255, 96, 255)", +"hwb(300 37.5% 0%)", "rgb(255, 96, 255)", +"hwb(300deg 37.5% 0% / 0)", "rgba(255, 96, 255, 0)", +"hwb(300 37.5% 0% / 0)", "rgba(255, 96, 255, 0)", +"hwb(300deg 37.5% 0% / 0.2)", "rgba(255, 96, 255, 0.2)", +"hwb(300 37.5% 0% / 0.2)", "rgba(255, 96, 255, 0.2)", +"hwb(300deg 37.5% 0% / 1)", "rgb(255, 96, 255)", +"hwb(300 37.5% 0% / 1)", "rgb(255, 96, 255)", +"hwb(300deg 37.5% 12.5%)", "rgb(223, 96, 223)", +"hwb(300 37.5% 12.5%)", "rgb(223, 96, 223)", +"hwb(300deg 37.5% 12.5% / 0)", "rgba(223, 96, 223, 0)", +"hwb(300 37.5% 12.5% / 0)", "rgba(223, 96, 223, 0)", +"hwb(300deg 37.5% 12.5% / 0.2)", "rgba(223, 96, 223, 0.2)", +"hwb(300 37.5% 12.5% / 0.2)", "rgba(223, 96, 223, 0.2)", +"hwb(300deg 37.5% 12.5% / 1)", "rgb(223, 96, 223)", +"hwb(300 37.5% 12.5% / 1)", "rgb(223, 96, 223)", +"hwb(300deg 37.5% 25%)", "rgb(191, 96, 191)", +"hwb(300 37.5% 25%)", "rgb(191, 96, 191)", +"hwb(300deg 37.5% 25% / 0)", "rgba(191, 96, 191, 0)", +"hwb(300 37.5% 25% / 0)", "rgba(191, 96, 191, 0)", +"hwb(300deg 37.5% 25% / 0.2)", "rgba(191, 96, 191, 0.2)", +"hwb(300 37.5% 25% / 0.2)", "rgba(191, 96, 191, 0.2)", +"hwb(300deg 37.5% 25% / 1)", "rgb(191, 96, 191)", +"hwb(300 37.5% 25% / 1)", "rgb(191, 96, 191)", +"hwb(300deg 37.5% 37.5%)", "rgb(159, 96, 159)", +"hwb(300 37.5% 37.5%)", "rgb(159, 96, 159)", +"hwb(300deg 37.5% 37.5% / 0)", "rgba(159, 96, 159, 0)", +"hwb(300 37.5% 37.5% / 0)", "rgba(159, 96, 159, 0)", +"hwb(300deg 37.5% 37.5% / 0.2)", "rgba(159, 96, 159, 0.2)", +"hwb(300 37.5% 37.5% / 0.2)", "rgba(159, 96, 159, 0.2)", +"hwb(300deg 37.5% 37.5% / 1)", "rgb(159, 96, 159)", +"hwb(300 37.5% 37.5% / 1)", "rgb(159, 96, 159)", +"hwb(300deg 37.5% 50%)", "rgb(128, 96, 128)", +"hwb(300 37.5% 50%)", "rgb(128, 96, 128)", +"hwb(300deg 37.5% 50% / 0)", "rgba(128, 96, 128, 0)", +"hwb(300 37.5% 50% / 0)", "rgba(128, 96, 128, 0)", +"hwb(300deg 37.5% 50% / 0.2)", "rgba(128, 96, 128, 0.2)", +"hwb(300 37.5% 50% / 0.2)", "rgba(128, 96, 128, 0.2)", +"hwb(300deg 37.5% 50% / 1)", "rgb(128, 96, 128)", +"hwb(300 37.5% 50% / 1)", "rgb(128, 96, 128)", +"hwb(300deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(300 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(300deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(300 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(300deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(300 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(300deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(300 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(300deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(300 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(300deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(300 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(300deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(300 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(300deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(300 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(300deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(300 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(300deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(300 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(300deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(300 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(300deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(300 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(300deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(300 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(300deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(300 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(300deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(300 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(300deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(300 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(300deg 50% 0%)", "rgb(255, 128, 255)", +"hwb(300 50% 0%)", "rgb(255, 128, 255)", +"hwb(300deg 50% 0% / 0)", "rgba(255, 128, 255, 0)", +"hwb(300 50% 0% / 0)", "rgba(255, 128, 255, 0)", +"hwb(300deg 50% 0% / 0.2)", "rgba(255, 128, 255, 0.2)", +"hwb(300 50% 0% / 0.2)", "rgba(255, 128, 255, 0.2)", +"hwb(300deg 50% 0% / 1)", "rgb(255, 128, 255)", +"hwb(300 50% 0% / 1)", "rgb(255, 128, 255)", +"hwb(300deg 50% 12.5%)", "rgb(223, 128, 223)", +"hwb(300 50% 12.5%)", "rgb(223, 128, 223)", +"hwb(300deg 50% 12.5% / 0)", "rgba(223, 128, 223, 0)", +"hwb(300 50% 12.5% / 0)", "rgba(223, 128, 223, 0)", +"hwb(300deg 50% 12.5% / 0.2)", "rgba(223, 128, 223, 0.2)", +"hwb(300 50% 12.5% / 0.2)", "rgba(223, 128, 223, 0.2)", +"hwb(300deg 50% 12.5% / 1)", "rgb(223, 128, 223)", +"hwb(300 50% 12.5% / 1)", "rgb(223, 128, 223)", +"hwb(300deg 50% 25%)", "rgb(191, 128, 191)", +"hwb(300 50% 25%)", "rgb(191, 128, 191)", +"hwb(300deg 50% 25% / 0)", "rgba(191, 128, 191, 0)", +"hwb(300 50% 25% / 0)", "rgba(191, 128, 191, 0)", +"hwb(300deg 50% 25% / 0.2)", "rgba(191, 128, 191, 0.2)", +"hwb(300 50% 25% / 0.2)", "rgba(191, 128, 191, 0.2)", +"hwb(300deg 50% 25% / 1)", "rgb(191, 128, 191)", +"hwb(300 50% 25% / 1)", "rgb(191, 128, 191)", +"hwb(300deg 50% 37.5%)", "rgb(159, 128, 159)", +"hwb(300 50% 37.5%)", "rgb(159, 128, 159)", +"hwb(300deg 50% 37.5% / 0)", "rgba(159, 128, 159, 0)", +"hwb(300 50% 37.5% / 0)", "rgba(159, 128, 159, 0)", +"hwb(300deg 50% 37.5% / 0.2)", "rgba(159, 128, 159, 0.2)", +"hwb(300 50% 37.5% / 0.2)", "rgba(159, 128, 159, 0.2)", +"hwb(300deg 50% 37.5% / 1)", "rgb(159, 128, 159)", +"hwb(300 50% 37.5% / 1)", "rgb(159, 128, 159)", +"hwb(300deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(300 50% 50%)", "rgb(128, 128, 128)", +"hwb(300deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(300 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(300deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(300 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(300deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(300 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(300deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(300 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(300deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(300 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(300deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(300 50% 75%)", "rgb(102, 102, 102)", +"hwb(300deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(300 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(300deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(300 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(300deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(300 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(300deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(300 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(300deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(300 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(300deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(300 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(300deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(300 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(300deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(300 50% 100%)", "rgb(85, 85, 85)", +"hwb(300deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(300 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(300deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(300 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(300deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(300 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(300deg 62.5% 0%)", "rgb(255, 159, 255)", +"hwb(300 62.5% 0%)", "rgb(255, 159, 255)", +"hwb(300deg 62.5% 0% / 0)", "rgba(255, 159, 255, 0)", +"hwb(300 62.5% 0% / 0)", "rgba(255, 159, 255, 0)", +"hwb(300deg 62.5% 0% / 0.2)", "rgba(255, 159, 255, 0.2)", +"hwb(300 62.5% 0% / 0.2)", "rgba(255, 159, 255, 0.2)", +"hwb(300deg 62.5% 0% / 1)", "rgb(255, 159, 255)", +"hwb(300 62.5% 0% / 1)", "rgb(255, 159, 255)", +"hwb(300deg 62.5% 12.5%)", "rgb(223, 159, 223)", +"hwb(300 62.5% 12.5%)", "rgb(223, 159, 223)", +"hwb(300deg 62.5% 12.5% / 0)", "rgba(223, 159, 223, 0)", +"hwb(300 62.5% 12.5% / 0)", "rgba(223, 159, 223, 0)", +"hwb(300deg 62.5% 12.5% / 0.2)", "rgba(223, 159, 223, 0.2)", +"hwb(300 62.5% 12.5% / 0.2)", "rgba(223, 159, 223, 0.2)", +"hwb(300deg 62.5% 12.5% / 1)", "rgb(223, 159, 223)", +"hwb(300 62.5% 12.5% / 1)", "rgb(223, 159, 223)", +"hwb(300deg 62.5% 25%)", "rgb(191, 159, 191)", +"hwb(300 62.5% 25%)", "rgb(191, 159, 191)", +"hwb(300deg 62.5% 25% / 0)", "rgba(191, 159, 191, 0)", +"hwb(300 62.5% 25% / 0)", "rgba(191, 159, 191, 0)", +"hwb(300deg 62.5% 25% / 0.2)", "rgba(191, 159, 191, 0.2)", +"hwb(300 62.5% 25% / 0.2)", "rgba(191, 159, 191, 0.2)", +"hwb(300deg 62.5% 25% / 1)", "rgb(191, 159, 191)", +"hwb(300 62.5% 25% / 1)", "rgb(191, 159, 191)", +"hwb(300deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(300 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(300deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(300 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(300deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(300 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(300deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(300 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(300deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(300 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(300deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(300 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(300deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(300 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(300deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(300 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(300deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(300 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(300deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(300 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(300deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(300 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(300deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(300 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(300deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(300 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(300deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(300 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(300deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(300 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(300deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(300 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(300deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(300 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(300deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(300 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(300deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(300 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(300deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(300 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(300deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(300 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(300deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(300 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(300deg 75% 0%)", "rgb(255, 191, 255)", +"hwb(300 75% 0%)", "rgb(255, 191, 255)", +"hwb(300deg 75% 0% / 0)", "rgba(255, 191, 255, 0)", +"hwb(300 75% 0% / 0)", "rgba(255, 191, 255, 0)", +"hwb(300deg 75% 0% / 0.2)", "rgba(255, 191, 255, 0.2)", +"hwb(300 75% 0% / 0.2)", "rgba(255, 191, 255, 0.2)", +"hwb(300deg 75% 0% / 1)", "rgb(255, 191, 255)", +"hwb(300 75% 0% / 1)", "rgb(255, 191, 255)", +"hwb(300deg 75% 12.5%)", "rgb(223, 191, 223)", +"hwb(300 75% 12.5%)", "rgb(223, 191, 223)", +"hwb(300deg 75% 12.5% / 0)", "rgba(223, 191, 223, 0)", +"hwb(300 75% 12.5% / 0)", "rgba(223, 191, 223, 0)", +"hwb(300deg 75% 12.5% / 0.2)", "rgba(223, 191, 223, 0.2)", +"hwb(300 75% 12.5% / 0.2)", "rgba(223, 191, 223, 0.2)", +"hwb(300deg 75% 12.5% / 1)", "rgb(223, 191, 223)", +"hwb(300 75% 12.5% / 1)", "rgb(223, 191, 223)", +"hwb(300deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(300 75% 25%)", "rgb(191, 191, 191)", +"hwb(300deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(300 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(300deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(300 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(300deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(300 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(300deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(300 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(300deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(300 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(300deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(300 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(300deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(300 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(300deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(300 75% 50%)", "rgb(153, 153, 153)", +"hwb(300deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(300 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(300deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(300 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(300deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(300 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(300deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(300 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(300deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(300 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(300deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(300 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(300deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(300 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(300deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(300 75% 75%)", "rgb(128, 128, 128)", +"hwb(300deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(300 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(300deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(300 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(300deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(300 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(300deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(300 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(300deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(300 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(300deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(300 75% 100%)", "rgb(109, 109, 109)", +"hwb(300deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(300 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(300deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(300 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(300deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(300 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(300deg 87.5% 0%)", "rgb(255, 223, 255)", +"hwb(300 87.5% 0%)", "rgb(255, 223, 255)", +"hwb(300deg 87.5% 0% / 0)", "rgba(255, 223, 255, 0)", +"hwb(300 87.5% 0% / 0)", "rgba(255, 223, 255, 0)", +"hwb(300deg 87.5% 0% / 0.2)", "rgba(255, 223, 255, 0.2)", +"hwb(300 87.5% 0% / 0.2)", "rgba(255, 223, 255, 0.2)", +"hwb(300deg 87.5% 0% / 1)", "rgb(255, 223, 255)", +"hwb(300 87.5% 0% / 1)", "rgb(255, 223, 255)", +"hwb(300deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(300 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(300deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(300 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(300deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(300 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(300deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(300 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(300deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(300 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(300deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(300 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(300deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(300 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(300deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(300 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(300deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(300 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(300deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(300 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(300deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(300 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(300deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(300 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(300deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(300 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(300deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(300 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(300deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(300 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(300deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(300 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(300deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(300 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(300deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(300 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(300deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(300 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(300deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(300 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(300deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(300 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(300deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(300 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(300deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(300 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(300deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(300 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(300deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(300 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(300deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(300 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(300deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(300 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(300deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(300 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(300deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(300 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(300deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(300 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(300deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(300 100% 0%)", "rgb(255, 255, 255)", +"hwb(300deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(300 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(300deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(300 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(300deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(300 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(300deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(300 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(300deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(300 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(300deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(300 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(300deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(300 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(300deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(300 100% 25%)", "rgb(204, 204, 204)", +"hwb(300deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(300 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(300deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(300 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(300deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(300 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(300deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(300 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(300deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(300 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(300deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(300 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(300deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(300 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(300deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(300 100% 50%)", "rgb(170, 170, 170)", +"hwb(300deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(300 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(300deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(300 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(300deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(300 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(300deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(300 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(300deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(300 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(300deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(300 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(300deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(300 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(300deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(300 100% 75%)", "rgb(146, 146, 146)", +"hwb(300deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(300 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(300deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(300 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(300deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(300 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(300deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(300 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(300deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(300 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(300deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(300 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(300deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(300 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(300deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(300 100% 100%)", "rgb(128, 128, 128)", +"hwb(300deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(300deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(300deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(300 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(330deg 0% 0%)", "rgb(255, 0, 128)", +"hwb(330 0% 0%)", "rgb(255, 0, 128)", +"hwb(330deg 0% 0% / 0)", "rgba(255, 0, 128, 0)", +"hwb(330 0% 0% / 0)", "rgba(255, 0, 128, 0)", +"hwb(330deg 0% 0% / 0.2)", "rgba(255, 0, 128, 0.2)", +"hwb(330 0% 0% / 0.2)", "rgba(255, 0, 128, 0.2)", +"hwb(330deg 0% 0% / 1)", "rgb(255, 0, 128)", +"hwb(330 0% 0% / 1)", "rgb(255, 0, 128)", +"hwb(330deg 0% 12.5%)", "rgb(223, 0, 112)", +"hwb(330 0% 12.5%)", "rgb(223, 0, 112)", +"hwb(330deg 0% 12.5% / 0)", "rgba(223, 0, 112, 0)", +"hwb(330 0% 12.5% / 0)", "rgba(223, 0, 112, 0)", +"hwb(330deg 0% 12.5% / 0.2)", "rgba(223, 0, 112, 0.2)", +"hwb(330 0% 12.5% / 0.2)", "rgba(223, 0, 112, 0.2)", +"hwb(330deg 0% 12.5% / 1)", "rgb(223, 0, 112)", +"hwb(330 0% 12.5% / 1)", "rgb(223, 0, 112)", +"hwb(330deg 0% 25%)", "rgb(191, 0, 96)", +"hwb(330 0% 25%)", "rgb(191, 0, 96)", +"hwb(330deg 0% 25% / 0)", "rgba(191, 0, 96, 0)", +"hwb(330 0% 25% / 0)", "rgba(191, 0, 96, 0)", +"hwb(330deg 0% 25% / 0.2)", "rgba(191, 0, 96, 0.2)", +"hwb(330 0% 25% / 0.2)", "rgba(191, 0, 96, 0.2)", +"hwb(330deg 0% 25% / 1)", "rgb(191, 0, 96)", +"hwb(330 0% 25% / 1)", "rgb(191, 0, 96)", +"hwb(330deg 0% 37.5%)", "rgb(159, 0, 80)", +"hwb(330 0% 37.5%)", "rgb(159, 0, 80)", +"hwb(330deg 0% 37.5% / 0)", "rgba(159, 0, 80, 0)", +"hwb(330 0% 37.5% / 0)", "rgba(159, 0, 80, 0)", +"hwb(330deg 0% 37.5% / 0.2)", "rgba(159, 0, 80, 0.2)", +"hwb(330 0% 37.5% / 0.2)", "rgba(159, 0, 80, 0.2)", +"hwb(330deg 0% 37.5% / 1)", "rgb(159, 0, 80)", +"hwb(330 0% 37.5% / 1)", "rgb(159, 0, 80)", +"hwb(330deg 0% 50%)", "rgb(128, 0, 64)", +"hwb(330 0% 50%)", "rgb(128, 0, 64)", +"hwb(330deg 0% 50% / 0)", "rgba(128, 0, 64, 0)", +"hwb(330 0% 50% / 0)", "rgba(128, 0, 64, 0)", +"hwb(330deg 0% 50% / 0.2)", "rgba(128, 0, 64, 0.2)", +"hwb(330 0% 50% / 0.2)", "rgba(128, 0, 64, 0.2)", +"hwb(330deg 0% 50% / 1)", "rgb(128, 0, 64)", +"hwb(330 0% 50% / 1)", "rgb(128, 0, 64)", +"hwb(330deg 0% 62.5%)", "rgb(96, 0, 48)", +"hwb(330 0% 62.5%)", "rgb(96, 0, 48)", +"hwb(330deg 0% 62.5% / 0)", "rgba(96, 0, 48, 0)", +"hwb(330 0% 62.5% / 0)", "rgba(96, 0, 48, 0)", +"hwb(330deg 0% 62.5% / 0.2)", "rgba(96, 0, 48, 0.2)", +"hwb(330 0% 62.5% / 0.2)", "rgba(96, 0, 48, 0.2)", +"hwb(330deg 0% 62.5% / 1)", "rgb(96, 0, 48)", +"hwb(330 0% 62.5% / 1)", "rgb(96, 0, 48)", +"hwb(330deg 0% 75%)", "rgb(64, 0, 32)", +"hwb(330 0% 75%)", "rgb(64, 0, 32)", +"hwb(330deg 0% 75% / 0)", "rgba(64, 0, 32, 0)", +"hwb(330 0% 75% / 0)", "rgba(64, 0, 32, 0)", +"hwb(330deg 0% 75% / 0.2)", "rgba(64, 0, 32, 0.2)", +"hwb(330 0% 75% / 0.2)", "rgba(64, 0, 32, 0.2)", +"hwb(330deg 0% 75% / 1)", "rgb(64, 0, 32)", +"hwb(330 0% 75% / 1)", "rgb(64, 0, 32)", +"hwb(330deg 0% 87.5%)", "rgb(32, 0, 16)", +"hwb(330 0% 87.5%)", "rgb(32, 0, 16)", +"hwb(330deg 0% 87.5% / 0)", "rgba(32, 0, 16, 0)", +"hwb(330 0% 87.5% / 0)", "rgba(32, 0, 16, 0)", +"hwb(330deg 0% 87.5% / 0.2)", "rgba(32, 0, 16, 0.2)", +"hwb(330 0% 87.5% / 0.2)", "rgba(32, 0, 16, 0.2)", +"hwb(330deg 0% 87.5% / 1)", "rgb(32, 0, 16)", +"hwb(330 0% 87.5% / 1)", "rgb(32, 0, 16)", +"hwb(330deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(330 0% 100%)", "rgb(0, 0, 0)", +"hwb(330deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(330 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(330deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(330 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(330deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(330 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(330deg 12.5% 0%)", "rgb(255, 32, 143)", +"hwb(330 12.5% 0%)", "rgb(255, 32, 143)", +"hwb(330deg 12.5% 0% / 0)", "rgba(255, 32, 143, 0)", +"hwb(330 12.5% 0% / 0)", "rgba(255, 32, 143, 0)", +"hwb(330deg 12.5% 0% / 0.2)", "rgba(255, 32, 143, 0.2)", +"hwb(330 12.5% 0% / 0.2)", "rgba(255, 32, 143, 0.2)", +"hwb(330deg 12.5% 0% / 1)", "rgb(255, 32, 143)", +"hwb(330 12.5% 0% / 1)", "rgb(255, 32, 143)", +"hwb(330deg 12.5% 12.5%)", "rgb(223, 32, 128)", +"hwb(330 12.5% 12.5%)", "rgb(223, 32, 128)", +"hwb(330deg 12.5% 12.5% / 0)", "rgba(223, 32, 128, 0)", +"hwb(330 12.5% 12.5% / 0)", "rgba(223, 32, 128, 0)", +"hwb(330deg 12.5% 12.5% / 0.2)", "rgba(223, 32, 128, 0.2)", +"hwb(330 12.5% 12.5% / 0.2)", "rgba(223, 32, 128, 0.2)", +"hwb(330deg 12.5% 12.5% / 1)", "rgb(223, 32, 128)", +"hwb(330 12.5% 12.5% / 1)", "rgb(223, 32, 128)", +"hwb(330deg 12.5% 25%)", "rgb(191, 32, 112)", +"hwb(330 12.5% 25%)", "rgb(191, 32, 112)", +"hwb(330deg 12.5% 25% / 0)", "rgba(191, 32, 112, 0)", +"hwb(330 12.5% 25% / 0)", "rgba(191, 32, 112, 0)", +"hwb(330deg 12.5% 25% / 0.2)", "rgba(191, 32, 112, 0.2)", +"hwb(330 12.5% 25% / 0.2)", "rgba(191, 32, 112, 0.2)", +"hwb(330deg 12.5% 25% / 1)", "rgb(191, 32, 112)", +"hwb(330 12.5% 25% / 1)", "rgb(191, 32, 112)", +"hwb(330deg 12.5% 37.5%)", "rgb(159, 32, 96)", +"hwb(330 12.5% 37.5%)", "rgb(159, 32, 96)", +"hwb(330deg 12.5% 37.5% / 0)", "rgba(159, 32, 96, 0)", +"hwb(330 12.5% 37.5% / 0)", "rgba(159, 32, 96, 0)", +"hwb(330deg 12.5% 37.5% / 0.2)", "rgba(159, 32, 96, 0.2)", +"hwb(330 12.5% 37.5% / 0.2)", "rgba(159, 32, 96, 0.2)", +"hwb(330deg 12.5% 37.5% / 1)", "rgb(159, 32, 96)", +"hwb(330 12.5% 37.5% / 1)", "rgb(159, 32, 96)", +"hwb(330deg 12.5% 50%)", "rgb(128, 32, 80)", +"hwb(330 12.5% 50%)", "rgb(128, 32, 80)", +"hwb(330deg 12.5% 50% / 0)", "rgba(128, 32, 80, 0)", +"hwb(330 12.5% 50% / 0)", "rgba(128, 32, 80, 0)", +"hwb(330deg 12.5% 50% / 0.2)", "rgba(128, 32, 80, 0.2)", +"hwb(330 12.5% 50% / 0.2)", "rgba(128, 32, 80, 0.2)", +"hwb(330deg 12.5% 50% / 1)", "rgb(128, 32, 80)", +"hwb(330 12.5% 50% / 1)", "rgb(128, 32, 80)", +"hwb(330deg 12.5% 62.5%)", "rgb(96, 32, 64)", +"hwb(330 12.5% 62.5%)", "rgb(96, 32, 64)", +"hwb(330deg 12.5% 62.5% / 0)", "rgba(96, 32, 64, 0)", +"hwb(330 12.5% 62.5% / 0)", "rgba(96, 32, 64, 0)", +"hwb(330deg 12.5% 62.5% / 0.2)", "rgba(96, 32, 64, 0.2)", +"hwb(330 12.5% 62.5% / 0.2)", "rgba(96, 32, 64, 0.2)", +"hwb(330deg 12.5% 62.5% / 1)", "rgb(96, 32, 64)", +"hwb(330 12.5% 62.5% / 1)", "rgb(96, 32, 64)", +"hwb(330deg 12.5% 75%)", "rgb(64, 32, 48)", +"hwb(330 12.5% 75%)", "rgb(64, 32, 48)", +"hwb(330deg 12.5% 75% / 0)", "rgba(64, 32, 48, 0)", +"hwb(330 12.5% 75% / 0)", "rgba(64, 32, 48, 0)", +"hwb(330deg 12.5% 75% / 0.2)", "rgba(64, 32, 48, 0.2)", +"hwb(330 12.5% 75% / 0.2)", "rgba(64, 32, 48, 0.2)", +"hwb(330deg 12.5% 75% / 1)", "rgb(64, 32, 48)", +"hwb(330 12.5% 75% / 1)", "rgb(64, 32, 48)", +"hwb(330deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(330 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(330deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(330 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(330deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(330 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(330deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(330 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(330deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(330 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(330deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(330 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(330deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(330 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(330deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(330 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(330deg 25% 0%)", "rgb(255, 64, 159)", +"hwb(330 25% 0%)", "rgb(255, 64, 159)", +"hwb(330deg 25% 0% / 0)", "rgba(255, 64, 159, 0)", +"hwb(330 25% 0% / 0)", "rgba(255, 64, 159, 0)", +"hwb(330deg 25% 0% / 0.2)", "rgba(255, 64, 159, 0.2)", +"hwb(330 25% 0% / 0.2)", "rgba(255, 64, 159, 0.2)", +"hwb(330deg 25% 0% / 1)", "rgb(255, 64, 159)", +"hwb(330 25% 0% / 1)", "rgb(255, 64, 159)", +"hwb(330deg 25% 12.5%)", "rgb(223, 64, 143)", +"hwb(330 25% 12.5%)", "rgb(223, 64, 143)", +"hwb(330deg 25% 12.5% / 0)", "rgba(223, 64, 143, 0)", +"hwb(330 25% 12.5% / 0)", "rgba(223, 64, 143, 0)", +"hwb(330deg 25% 12.5% / 0.2)", "rgba(223, 64, 143, 0.2)", +"hwb(330 25% 12.5% / 0.2)", "rgba(223, 64, 143, 0.2)", +"hwb(330deg 25% 12.5% / 1)", "rgb(223, 64, 143)", +"hwb(330 25% 12.5% / 1)", "rgb(223, 64, 143)", +"hwb(330deg 25% 25%)", "rgb(191, 64, 128)", +"hwb(330 25% 25%)", "rgb(191, 64, 128)", +"hwb(330deg 25% 25% / 0)", "rgba(191, 64, 128, 0)", +"hwb(330 25% 25% / 0)", "rgba(191, 64, 128, 0)", +"hwb(330deg 25% 25% / 0.2)", "rgba(191, 64, 128, 0.2)", +"hwb(330 25% 25% / 0.2)", "rgba(191, 64, 128, 0.2)", +"hwb(330deg 25% 25% / 1)", "rgb(191, 64, 128)", +"hwb(330 25% 25% / 1)", "rgb(191, 64, 128)", +"hwb(330deg 25% 37.5%)", "rgb(159, 64, 112)", +"hwb(330 25% 37.5%)", "rgb(159, 64, 112)", +"hwb(330deg 25% 37.5% / 0)", "rgba(159, 64, 112, 0)", +"hwb(330 25% 37.5% / 0)", "rgba(159, 64, 112, 0)", +"hwb(330deg 25% 37.5% / 0.2)", "rgba(159, 64, 112, 0.2)", +"hwb(330 25% 37.5% / 0.2)", "rgba(159, 64, 112, 0.2)", +"hwb(330deg 25% 37.5% / 1)", "rgb(159, 64, 112)", +"hwb(330 25% 37.5% / 1)", "rgb(159, 64, 112)", +"hwb(330deg 25% 50%)", "rgb(128, 64, 96)", +"hwb(330 25% 50%)", "rgb(128, 64, 96)", +"hwb(330deg 25% 50% / 0)", "rgba(128, 64, 96, 0)", +"hwb(330 25% 50% / 0)", "rgba(128, 64, 96, 0)", +"hwb(330deg 25% 50% / 0.2)", "rgba(128, 64, 96, 0.2)", +"hwb(330 25% 50% / 0.2)", "rgba(128, 64, 96, 0.2)", +"hwb(330deg 25% 50% / 1)", "rgb(128, 64, 96)", +"hwb(330 25% 50% / 1)", "rgb(128, 64, 96)", +"hwb(330deg 25% 62.5%)", "rgb(96, 64, 80)", +"hwb(330 25% 62.5%)", "rgb(96, 64, 80)", +"hwb(330deg 25% 62.5% / 0)", "rgba(96, 64, 80, 0)", +"hwb(330 25% 62.5% / 0)", "rgba(96, 64, 80, 0)", +"hwb(330deg 25% 62.5% / 0.2)", "rgba(96, 64, 80, 0.2)", +"hwb(330 25% 62.5% / 0.2)", "rgba(96, 64, 80, 0.2)", +"hwb(330deg 25% 62.5% / 1)", "rgb(96, 64, 80)", +"hwb(330 25% 62.5% / 1)", "rgb(96, 64, 80)", +"hwb(330deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(330 25% 75%)", "rgb(64, 64, 64)", +"hwb(330deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(330 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(330deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(330 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(330deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(330 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(330deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(330 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(330deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(330 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(330deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(330 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(330deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(330 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(330deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(330 25% 100%)", "rgb(51, 51, 51)", +"hwb(330deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(330 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(330deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(330 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(330deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(330 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(330deg 37.5% 0%)", "rgb(255, 96, 175)", +"hwb(330 37.5% 0%)", "rgb(255, 96, 175)", +"hwb(330deg 37.5% 0% / 0)", "rgba(255, 96, 175, 0)", +"hwb(330 37.5% 0% / 0)", "rgba(255, 96, 175, 0)", +"hwb(330deg 37.5% 0% / 0.2)", "rgba(255, 96, 175, 0.2)", +"hwb(330 37.5% 0% / 0.2)", "rgba(255, 96, 175, 0.2)", +"hwb(330deg 37.5% 0% / 1)", "rgb(255, 96, 175)", +"hwb(330 37.5% 0% / 1)", "rgb(255, 96, 175)", +"hwb(330deg 37.5% 12.5%)", "rgb(223, 96, 159)", +"hwb(330 37.5% 12.5%)", "rgb(223, 96, 159)", +"hwb(330deg 37.5% 12.5% / 0)", "rgba(223, 96, 159, 0)", +"hwb(330 37.5% 12.5% / 0)", "rgba(223, 96, 159, 0)", +"hwb(330deg 37.5% 12.5% / 0.2)", "rgba(223, 96, 159, 0.2)", +"hwb(330 37.5% 12.5% / 0.2)", "rgba(223, 96, 159, 0.2)", +"hwb(330deg 37.5% 12.5% / 1)", "rgb(223, 96, 159)", +"hwb(330 37.5% 12.5% / 1)", "rgb(223, 96, 159)", +"hwb(330deg 37.5% 25%)", "rgb(191, 96, 143)", +"hwb(330 37.5% 25%)", "rgb(191, 96, 143)", +"hwb(330deg 37.5% 25% / 0)", "rgba(191, 96, 143, 0)", +"hwb(330 37.5% 25% / 0)", "rgba(191, 96, 143, 0)", +"hwb(330deg 37.5% 25% / 0.2)", "rgba(191, 96, 143, 0.2)", +"hwb(330 37.5% 25% / 0.2)", "rgba(191, 96, 143, 0.2)", +"hwb(330deg 37.5% 25% / 1)", "rgb(191, 96, 143)", +"hwb(330 37.5% 25% / 1)", "rgb(191, 96, 143)", +"hwb(330deg 37.5% 37.5%)", "rgb(159, 96, 128)", +"hwb(330 37.5% 37.5%)", "rgb(159, 96, 128)", +"hwb(330deg 37.5% 37.5% / 0)", "rgba(159, 96, 128, 0)", +"hwb(330 37.5% 37.5% / 0)", "rgba(159, 96, 128, 0)", +"hwb(330deg 37.5% 37.5% / 0.2)", "rgba(159, 96, 128, 0.2)", +"hwb(330 37.5% 37.5% / 0.2)", "rgba(159, 96, 128, 0.2)", +"hwb(330deg 37.5% 37.5% / 1)", "rgb(159, 96, 128)", +"hwb(330 37.5% 37.5% / 1)", "rgb(159, 96, 128)", +"hwb(330deg 37.5% 50%)", "rgb(128, 96, 112)", +"hwb(330 37.5% 50%)", "rgb(128, 96, 112)", +"hwb(330deg 37.5% 50% / 0)", "rgba(128, 96, 112, 0)", +"hwb(330 37.5% 50% / 0)", "rgba(128, 96, 112, 0)", +"hwb(330deg 37.5% 50% / 0.2)", "rgba(128, 96, 112, 0.2)", +"hwb(330 37.5% 50% / 0.2)", "rgba(128, 96, 112, 0.2)", +"hwb(330deg 37.5% 50% / 1)", "rgb(128, 96, 112)", +"hwb(330 37.5% 50% / 1)", "rgb(128, 96, 112)", +"hwb(330deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(330 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(330deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(330 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(330deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(330 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(330deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(330 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(330deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(330 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(330deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(330 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(330deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(330 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(330deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(330 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(330deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(330 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(330deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(330 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(330deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(330 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(330deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(330 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(330deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(330 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(330deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(330 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(330deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(330 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(330deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(330 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(330deg 50% 0%)", "rgb(255, 128, 191)", +"hwb(330 50% 0%)", "rgb(255, 128, 191)", +"hwb(330deg 50% 0% / 0)", "rgba(255, 128, 191, 0)", +"hwb(330 50% 0% / 0)", "rgba(255, 128, 191, 0)", +"hwb(330deg 50% 0% / 0.2)", "rgba(255, 128, 191, 0.2)", +"hwb(330 50% 0% / 0.2)", "rgba(255, 128, 191, 0.2)", +"hwb(330deg 50% 0% / 1)", "rgb(255, 128, 191)", +"hwb(330 50% 0% / 1)", "rgb(255, 128, 191)", +"hwb(330deg 50% 12.5%)", "rgb(223, 128, 175)", +"hwb(330 50% 12.5%)", "rgb(223, 128, 175)", +"hwb(330deg 50% 12.5% / 0)", "rgba(223, 128, 175, 0)", +"hwb(330 50% 12.5% / 0)", "rgba(223, 128, 175, 0)", +"hwb(330deg 50% 12.5% / 0.2)", "rgba(223, 128, 175, 0.2)", +"hwb(330 50% 12.5% / 0.2)", "rgba(223, 128, 175, 0.2)", +"hwb(330deg 50% 12.5% / 1)", "rgb(223, 128, 175)", +"hwb(330 50% 12.5% / 1)", "rgb(223, 128, 175)", +"hwb(330deg 50% 25%)", "rgb(191, 128, 159)", +"hwb(330 50% 25%)", "rgb(191, 128, 159)", +"hwb(330deg 50% 25% / 0)", "rgba(191, 128, 159, 0)", +"hwb(330 50% 25% / 0)", "rgba(191, 128, 159, 0)", +"hwb(330deg 50% 25% / 0.2)", "rgba(191, 128, 159, 0.2)", +"hwb(330 50% 25% / 0.2)", "rgba(191, 128, 159, 0.2)", +"hwb(330deg 50% 25% / 1)", "rgb(191, 128, 159)", +"hwb(330 50% 25% / 1)", "rgb(191, 128, 159)", +"hwb(330deg 50% 37.5%)", "rgb(159, 128, 143)", +"hwb(330 50% 37.5%)", "rgb(159, 128, 143)", +"hwb(330deg 50% 37.5% / 0)", "rgba(159, 128, 143, 0)", +"hwb(330 50% 37.5% / 0)", "rgba(159, 128, 143, 0)", +"hwb(330deg 50% 37.5% / 0.2)", "rgba(159, 128, 143, 0.2)", +"hwb(330 50% 37.5% / 0.2)", "rgba(159, 128, 143, 0.2)", +"hwb(330deg 50% 37.5% / 1)", "rgb(159, 128, 143)", +"hwb(330 50% 37.5% / 1)", "rgb(159, 128, 143)", +"hwb(330deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(330 50% 50%)", "rgb(128, 128, 128)", +"hwb(330deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(330 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(330deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(330 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(330deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(330 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(330deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(330 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(330deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(330 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(330deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(330 50% 75%)", "rgb(102, 102, 102)", +"hwb(330deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(330 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(330deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(330 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(330deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(330 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(330deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(330 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(330deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(330 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(330deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(330 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(330deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(330 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(330deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(330 50% 100%)", "rgb(85, 85, 85)", +"hwb(330deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(330 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(330deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(330 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(330deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(330 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(330deg 62.5% 0%)", "rgb(255, 159, 207)", +"hwb(330 62.5% 0%)", "rgb(255, 159, 207)", +"hwb(330deg 62.5% 0% / 0)", "rgba(255, 159, 207, 0)", +"hwb(330 62.5% 0% / 0)", "rgba(255, 159, 207, 0)", +"hwb(330deg 62.5% 0% / 0.2)", "rgba(255, 159, 207, 0.2)", +"hwb(330 62.5% 0% / 0.2)", "rgba(255, 159, 207, 0.2)", +"hwb(330deg 62.5% 0% / 1)", "rgb(255, 159, 207)", +"hwb(330 62.5% 0% / 1)", "rgb(255, 159, 207)", +"hwb(330deg 62.5% 12.5%)", "rgb(223, 159, 191)", +"hwb(330 62.5% 12.5%)", "rgb(223, 159, 191)", +"hwb(330deg 62.5% 12.5% / 0)", "rgba(223, 159, 191, 0)", +"hwb(330 62.5% 12.5% / 0)", "rgba(223, 159, 191, 0)", +"hwb(330deg 62.5% 12.5% / 0.2)", "rgba(223, 159, 191, 0.2)", +"hwb(330 62.5% 12.5% / 0.2)", "rgba(223, 159, 191, 0.2)", +"hwb(330deg 62.5% 12.5% / 1)", "rgb(223, 159, 191)", +"hwb(330 62.5% 12.5% / 1)", "rgb(223, 159, 191)", +"hwb(330deg 62.5% 25%)", "rgb(191, 159, 175)", +"hwb(330 62.5% 25%)", "rgb(191, 159, 175)", +"hwb(330deg 62.5% 25% / 0)", "rgba(191, 159, 175, 0)", +"hwb(330 62.5% 25% / 0)", "rgba(191, 159, 175, 0)", +"hwb(330deg 62.5% 25% / 0.2)", "rgba(191, 159, 175, 0.2)", +"hwb(330 62.5% 25% / 0.2)", "rgba(191, 159, 175, 0.2)", +"hwb(330deg 62.5% 25% / 1)", "rgb(191, 159, 175)", +"hwb(330 62.5% 25% / 1)", "rgb(191, 159, 175)", +"hwb(330deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(330 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(330deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(330 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(330deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(330 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(330deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(330 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(330deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(330 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(330deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(330 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(330deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(330 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(330deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(330 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(330deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(330 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(330deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(330 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(330deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(330 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(330deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(330 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(330deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(330 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(330deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(330 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(330deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(330 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(330deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(330 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(330deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(330 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(330deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(330 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(330deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(330 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(330deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(330 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(330deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(330 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(330deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(330 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(330deg 75% 0%)", "rgb(255, 191, 223)", +"hwb(330 75% 0%)", "rgb(255, 191, 223)", +"hwb(330deg 75% 0% / 0)", "rgba(255, 191, 223, 0)", +"hwb(330 75% 0% / 0)", "rgba(255, 191, 223, 0)", +"hwb(330deg 75% 0% / 0.2)", "rgba(255, 191, 223, 0.2)", +"hwb(330 75% 0% / 0.2)", "rgba(255, 191, 223, 0.2)", +"hwb(330deg 75% 0% / 1)", "rgb(255, 191, 223)", +"hwb(330 75% 0% / 1)", "rgb(255, 191, 223)", +"hwb(330deg 75% 12.5%)", "rgb(223, 191, 207)", +"hwb(330 75% 12.5%)", "rgb(223, 191, 207)", +"hwb(330deg 75% 12.5% / 0)", "rgba(223, 191, 207, 0)", +"hwb(330 75% 12.5% / 0)", "rgba(223, 191, 207, 0)", +"hwb(330deg 75% 12.5% / 0.2)", "rgba(223, 191, 207, 0.2)", +"hwb(330 75% 12.5% / 0.2)", "rgba(223, 191, 207, 0.2)", +"hwb(330deg 75% 12.5% / 1)", "rgb(223, 191, 207)", +"hwb(330 75% 12.5% / 1)", "rgb(223, 191, 207)", +"hwb(330deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(330 75% 25%)", "rgb(191, 191, 191)", +"hwb(330deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(330 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(330deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(330 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(330deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(330 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(330deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(330 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(330deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(330 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(330deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(330 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(330deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(330 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(330deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(330 75% 50%)", "rgb(153, 153, 153)", +"hwb(330deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(330 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(330deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(330 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(330deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(330 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(330deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(330 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(330deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(330 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(330deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(330 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(330deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(330 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(330deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(330 75% 75%)", "rgb(128, 128, 128)", +"hwb(330deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(330 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(330deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(330 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(330deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(330 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(330deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(330 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(330deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(330 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(330deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(330 75% 100%)", "rgb(109, 109, 109)", +"hwb(330deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(330 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(330deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(330 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(330deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(330 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(330deg 87.5% 0%)", "rgb(255, 223, 239)", +"hwb(330 87.5% 0%)", "rgb(255, 223, 239)", +"hwb(330deg 87.5% 0% / 0)", "rgba(255, 223, 239, 0)", +"hwb(330 87.5% 0% / 0)", "rgba(255, 223, 239, 0)", +"hwb(330deg 87.5% 0% / 0.2)", "rgba(255, 223, 239, 0.2)", +"hwb(330 87.5% 0% / 0.2)", "rgba(255, 223, 239, 0.2)", +"hwb(330deg 87.5% 0% / 1)", "rgb(255, 223, 239)", +"hwb(330 87.5% 0% / 1)", "rgb(255, 223, 239)", +"hwb(330deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(330 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(330deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(330 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(330deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(330 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(330deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(330 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(330deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(330 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(330deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(330 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(330deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(330 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(330deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(330 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(330deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(330 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(330deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(330 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(330deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(330 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(330deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(330 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(330deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(330 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(330deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(330 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(330deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(330 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(330deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(330 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(330deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(330 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(330deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(330 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(330deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(330 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(330deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(330 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(330deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(330 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(330deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(330 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(330deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(330 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(330deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(330 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(330deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(330 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(330deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(330 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(330deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(330 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(330deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(330 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(330deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(330 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(330deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(330 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(330deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(330 100% 0%)", "rgb(255, 255, 255)", +"hwb(330deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(330 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(330deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(330 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(330deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(330 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(330deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(330 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(330deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(330 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(330deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(330 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(330deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(330 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(330deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(330 100% 25%)", "rgb(204, 204, 204)", +"hwb(330deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(330 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(330deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(330 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(330deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(330 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(330deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(330 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(330deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(330 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(330deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(330 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(330deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(330 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(330deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(330 100% 50%)", "rgb(170, 170, 170)", +"hwb(330deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(330 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(330deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(330 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(330deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(330 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(330deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(330 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(330deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(330 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(330deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(330 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(330deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(330 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(330deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(330 100% 75%)", "rgb(146, 146, 146)", +"hwb(330deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(330 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(330deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(330 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(330deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(330 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(330deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(330 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(330deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(330 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(330deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(330 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(330deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(330 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(330deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(330 100% 100%)", "rgb(128, 128, 128)", +"hwb(330deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(330deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(330deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(330 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(360deg 0% 0%)", "rgb(255, 0, 0)", +"hwb(360 0% 0%)", "rgb(255, 0, 0)", +"hwb(360deg 0% 0% / 0)", "rgba(255, 0, 0, 0)", +"hwb(360 0% 0% / 0)", "rgba(255, 0, 0, 0)", +"hwb(360deg 0% 0% / 0.2)", "rgba(255, 0, 0, 0.2)", +"hwb(360 0% 0% / 0.2)", "rgba(255, 0, 0, 0.2)", +"hwb(360deg 0% 0% / 1)", "rgb(255, 0, 0)", +"hwb(360 0% 0% / 1)", "rgb(255, 0, 0)", +"hwb(360deg 0% 12.5%)", "rgb(223, 0, 0)", +"hwb(360 0% 12.5%)", "rgb(223, 0, 0)", +"hwb(360deg 0% 12.5% / 0)", "rgba(223, 0, 0, 0)", +"hwb(360 0% 12.5% / 0)", "rgba(223, 0, 0, 0)", +"hwb(360deg 0% 12.5% / 0.2)", "rgba(223, 0, 0, 0.2)", +"hwb(360 0% 12.5% / 0.2)", "rgba(223, 0, 0, 0.2)", +"hwb(360deg 0% 12.5% / 1)", "rgb(223, 0, 0)", +"hwb(360 0% 12.5% / 1)", "rgb(223, 0, 0)", +"hwb(360deg 0% 25%)", "rgb(191, 0, 0)", +"hwb(360 0% 25%)", "rgb(191, 0, 0)", +"hwb(360deg 0% 25% / 0)", "rgba(191, 0, 0, 0)", +"hwb(360 0% 25% / 0)", "rgba(191, 0, 0, 0)", +"hwb(360deg 0% 25% / 0.2)", "rgba(191, 0, 0, 0.2)", +"hwb(360 0% 25% / 0.2)", "rgba(191, 0, 0, 0.2)", +"hwb(360deg 0% 25% / 1)", "rgb(191, 0, 0)", +"hwb(360 0% 25% / 1)", "rgb(191, 0, 0)", +"hwb(360deg 0% 37.5%)", "rgb(159, 0, 0)", +"hwb(360 0% 37.5%)", "rgb(159, 0, 0)", +"hwb(360deg 0% 37.5% / 0)", "rgba(159, 0, 0, 0)", +"hwb(360 0% 37.5% / 0)", "rgba(159, 0, 0, 0)", +"hwb(360deg 0% 37.5% / 0.2)", "rgba(159, 0, 0, 0.2)", +"hwb(360 0% 37.5% / 0.2)", "rgba(159, 0, 0, 0.2)", +"hwb(360deg 0% 37.5% / 1)", "rgb(159, 0, 0)", +"hwb(360 0% 37.5% / 1)", "rgb(159, 0, 0)", +"hwb(360deg 0% 50%)", "rgb(128, 0, 0)", +"hwb(360 0% 50%)", "rgb(128, 0, 0)", +"hwb(360deg 0% 50% / 0)", "rgba(128, 0, 0, 0)", +"hwb(360 0% 50% / 0)", "rgba(128, 0, 0, 0)", +"hwb(360deg 0% 50% / 0.2)", "rgba(128, 0, 0, 0.2)", +"hwb(360 0% 50% / 0.2)", "rgba(128, 0, 0, 0.2)", +"hwb(360deg 0% 50% / 1)", "rgb(128, 0, 0)", +"hwb(360 0% 50% / 1)", "rgb(128, 0, 0)", +"hwb(360deg 0% 62.5%)", "rgb(96, 0, 0)", +"hwb(360 0% 62.5%)", "rgb(96, 0, 0)", +"hwb(360deg 0% 62.5% / 0)", "rgba(96, 0, 0, 0)", +"hwb(360 0% 62.5% / 0)", "rgba(96, 0, 0, 0)", +"hwb(360deg 0% 62.5% / 0.2)", "rgba(96, 0, 0, 0.2)", +"hwb(360 0% 62.5% / 0.2)", "rgba(96, 0, 0, 0.2)", +"hwb(360deg 0% 62.5% / 1)", "rgb(96, 0, 0)", +"hwb(360 0% 62.5% / 1)", "rgb(96, 0, 0)", +"hwb(360deg 0% 75%)", "rgb(64, 0, 0)", +"hwb(360 0% 75%)", "rgb(64, 0, 0)", +"hwb(360deg 0% 75% / 0)", "rgba(64, 0, 0, 0)", +"hwb(360 0% 75% / 0)", "rgba(64, 0, 0, 0)", +"hwb(360deg 0% 75% / 0.2)", "rgba(64, 0, 0, 0.2)", +"hwb(360 0% 75% / 0.2)", "rgba(64, 0, 0, 0.2)", +"hwb(360deg 0% 75% / 1)", "rgb(64, 0, 0)", +"hwb(360 0% 75% / 1)", "rgb(64, 0, 0)", +"hwb(360deg 0% 87.5%)", "rgb(32, 0, 0)", +"hwb(360 0% 87.5%)", "rgb(32, 0, 0)", +"hwb(360deg 0% 87.5% / 0)", "rgba(32, 0, 0, 0)", +"hwb(360 0% 87.5% / 0)", "rgba(32, 0, 0, 0)", +"hwb(360deg 0% 87.5% / 0.2)", "rgba(32, 0, 0, 0.2)", +"hwb(360 0% 87.5% / 0.2)", "rgba(32, 0, 0, 0.2)", +"hwb(360deg 0% 87.5% / 1)", "rgb(32, 0, 0)", +"hwb(360 0% 87.5% / 1)", "rgb(32, 0, 0)", +"hwb(360deg 0% 100%)", "rgb(0, 0, 0)", +"hwb(360 0% 100%)", "rgb(0, 0, 0)", +"hwb(360deg 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(360 0% 100% / 0)", "rgba(0, 0, 0, 0)", +"hwb(360deg 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(360 0% 100% / 0.2)", "rgba(0, 0, 0, 0.2)", +"hwb(360deg 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(360 0% 100% / 1)", "rgb(0, 0, 0)", +"hwb(360deg 12.5% 0%)", "rgb(255, 32, 32)", +"hwb(360 12.5% 0%)", "rgb(255, 32, 32)", +"hwb(360deg 12.5% 0% / 0)", "rgba(255, 32, 32, 0)", +"hwb(360 12.5% 0% / 0)", "rgba(255, 32, 32, 0)", +"hwb(360deg 12.5% 0% / 0.2)", "rgba(255, 32, 32, 0.2)", +"hwb(360 12.5% 0% / 0.2)", "rgba(255, 32, 32, 0.2)", +"hwb(360deg 12.5% 0% / 1)", "rgb(255, 32, 32)", +"hwb(360 12.5% 0% / 1)", "rgb(255, 32, 32)", +"hwb(360deg 12.5% 12.5%)", "rgb(223, 32, 32)", +"hwb(360 12.5% 12.5%)", "rgb(223, 32, 32)", +"hwb(360deg 12.5% 12.5% / 0)", "rgba(223, 32, 32, 0)", +"hwb(360 12.5% 12.5% / 0)", "rgba(223, 32, 32, 0)", +"hwb(360deg 12.5% 12.5% / 0.2)", "rgba(223, 32, 32, 0.2)", +"hwb(360 12.5% 12.5% / 0.2)", "rgba(223, 32, 32, 0.2)", +"hwb(360deg 12.5% 12.5% / 1)", "rgb(223, 32, 32)", +"hwb(360 12.5% 12.5% / 1)", "rgb(223, 32, 32)", +"hwb(360deg 12.5% 25%)", "rgb(191, 32, 32)", +"hwb(360 12.5% 25%)", "rgb(191, 32, 32)", +"hwb(360deg 12.5% 25% / 0)", "rgba(191, 32, 32, 0)", +"hwb(360 12.5% 25% / 0)", "rgba(191, 32, 32, 0)", +"hwb(360deg 12.5% 25% / 0.2)", "rgba(191, 32, 32, 0.2)", +"hwb(360 12.5% 25% / 0.2)", "rgba(191, 32, 32, 0.2)", +"hwb(360deg 12.5% 25% / 1)", "rgb(191, 32, 32)", +"hwb(360 12.5% 25% / 1)", "rgb(191, 32, 32)", +"hwb(360deg 12.5% 37.5%)", "rgb(159, 32, 32)", +"hwb(360 12.5% 37.5%)", "rgb(159, 32, 32)", +"hwb(360deg 12.5% 37.5% / 0)", "rgba(159, 32, 32, 0)", +"hwb(360 12.5% 37.5% / 0)", "rgba(159, 32, 32, 0)", +"hwb(360deg 12.5% 37.5% / 0.2)", "rgba(159, 32, 32, 0.2)", +"hwb(360 12.5% 37.5% / 0.2)", "rgba(159, 32, 32, 0.2)", +"hwb(360deg 12.5% 37.5% / 1)", "rgb(159, 32, 32)", +"hwb(360 12.5% 37.5% / 1)", "rgb(159, 32, 32)", +"hwb(360deg 12.5% 50%)", "rgb(128, 32, 32)", +"hwb(360 12.5% 50%)", "rgb(128, 32, 32)", +"hwb(360deg 12.5% 50% / 0)", "rgba(128, 32, 32, 0)", +"hwb(360 12.5% 50% / 0)", "rgba(128, 32, 32, 0)", +"hwb(360deg 12.5% 50% / 0.2)", "rgba(128, 32, 32, 0.2)", +"hwb(360 12.5% 50% / 0.2)", "rgba(128, 32, 32, 0.2)", +"hwb(360deg 12.5% 50% / 1)", "rgb(128, 32, 32)", +"hwb(360 12.5% 50% / 1)", "rgb(128, 32, 32)", +"hwb(360deg 12.5% 62.5%)", "rgb(96, 32, 32)", +"hwb(360 12.5% 62.5%)", "rgb(96, 32, 32)", +"hwb(360deg 12.5% 62.5% / 0)", "rgba(96, 32, 32, 0)", +"hwb(360 12.5% 62.5% / 0)", "rgba(96, 32, 32, 0)", +"hwb(360deg 12.5% 62.5% / 0.2)", "rgba(96, 32, 32, 0.2)", +"hwb(360 12.5% 62.5% / 0.2)", "rgba(96, 32, 32, 0.2)", +"hwb(360deg 12.5% 62.5% / 1)", "rgb(96, 32, 32)", +"hwb(360 12.5% 62.5% / 1)", "rgb(96, 32, 32)", +"hwb(360deg 12.5% 75%)", "rgb(64, 32, 32)", +"hwb(360 12.5% 75%)", "rgb(64, 32, 32)", +"hwb(360deg 12.5% 75% / 0)", "rgba(64, 32, 32, 0)", +"hwb(360 12.5% 75% / 0)", "rgba(64, 32, 32, 0)", +"hwb(360deg 12.5% 75% / 0.2)", "rgba(64, 32, 32, 0.2)", +"hwb(360 12.5% 75% / 0.2)", "rgba(64, 32, 32, 0.2)", +"hwb(360deg 12.5% 75% / 1)", "rgb(64, 32, 32)", +"hwb(360 12.5% 75% / 1)", "rgb(64, 32, 32)", +"hwb(360deg 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(360 12.5% 87.5%)", "rgb(32, 32, 32)", +"hwb(360deg 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(360 12.5% 87.5% / 0)", "rgba(32, 32, 32, 0)", +"hwb(360deg 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(360 12.5% 87.5% / 0.2)", "rgba(32, 32, 32, 0.2)", +"hwb(360deg 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(360 12.5% 87.5% / 1)", "rgb(32, 32, 32)", +"hwb(360deg 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(360 12.5% 100%)", "rgb(28, 28, 28)", +"hwb(360deg 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(360 12.5% 100% / 0)", "rgba(28, 28, 28, 0)", +"hwb(360deg 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(360 12.5% 100% / 0.2)", "rgba(28, 28, 28, 0.2)", +"hwb(360deg 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(360 12.5% 100% / 1)", "rgb(28, 28, 28)", +"hwb(360deg 25% 0%)", "rgb(255, 64, 64)", +"hwb(360 25% 0%)", "rgb(255, 64, 64)", +"hwb(360deg 25% 0% / 0)", "rgba(255, 64, 64, 0)", +"hwb(360 25% 0% / 0)", "rgba(255, 64, 64, 0)", +"hwb(360deg 25% 0% / 0.2)", "rgba(255, 64, 64, 0.2)", +"hwb(360 25% 0% / 0.2)", "rgba(255, 64, 64, 0.2)", +"hwb(360deg 25% 0% / 1)", "rgb(255, 64, 64)", +"hwb(360 25% 0% / 1)", "rgb(255, 64, 64)", +"hwb(360deg 25% 12.5%)", "rgb(223, 64, 64)", +"hwb(360 25% 12.5%)", "rgb(223, 64, 64)", +"hwb(360deg 25% 12.5% / 0)", "rgba(223, 64, 64, 0)", +"hwb(360 25% 12.5% / 0)", "rgba(223, 64, 64, 0)", +"hwb(360deg 25% 12.5% / 0.2)", "rgba(223, 64, 64, 0.2)", +"hwb(360 25% 12.5% / 0.2)", "rgba(223, 64, 64, 0.2)", +"hwb(360deg 25% 12.5% / 1)", "rgb(223, 64, 64)", +"hwb(360 25% 12.5% / 1)", "rgb(223, 64, 64)", +"hwb(360deg 25% 25%)", "rgb(191, 64, 64)", +"hwb(360 25% 25%)", "rgb(191, 64, 64)", +"hwb(360deg 25% 25% / 0)", "rgba(191, 64, 64, 0)", +"hwb(360 25% 25% / 0)", "rgba(191, 64, 64, 0)", +"hwb(360deg 25% 25% / 0.2)", "rgba(191, 64, 64, 0.2)", +"hwb(360 25% 25% / 0.2)", "rgba(191, 64, 64, 0.2)", +"hwb(360deg 25% 25% / 1)", "rgb(191, 64, 64)", +"hwb(360 25% 25% / 1)", "rgb(191, 64, 64)", +"hwb(360deg 25% 37.5%)", "rgb(159, 64, 64)", +"hwb(360 25% 37.5%)", "rgb(159, 64, 64)", +"hwb(360deg 25% 37.5% / 0)", "rgba(159, 64, 64, 0)", +"hwb(360 25% 37.5% / 0)", "rgba(159, 64, 64, 0)", +"hwb(360deg 25% 37.5% / 0.2)", "rgba(159, 64, 64, 0.2)", +"hwb(360 25% 37.5% / 0.2)", "rgba(159, 64, 64, 0.2)", +"hwb(360deg 25% 37.5% / 1)", "rgb(159, 64, 64)", +"hwb(360 25% 37.5% / 1)", "rgb(159, 64, 64)", +"hwb(360deg 25% 50%)", "rgb(128, 64, 64)", +"hwb(360 25% 50%)", "rgb(128, 64, 64)", +"hwb(360deg 25% 50% / 0)", "rgba(128, 64, 64, 0)", +"hwb(360 25% 50% / 0)", "rgba(128, 64, 64, 0)", +"hwb(360deg 25% 50% / 0.2)", "rgba(128, 64, 64, 0.2)", +"hwb(360 25% 50% / 0.2)", "rgba(128, 64, 64, 0.2)", +"hwb(360deg 25% 50% / 1)", "rgb(128, 64, 64)", +"hwb(360 25% 50% / 1)", "rgb(128, 64, 64)", +"hwb(360deg 25% 62.5%)", "rgb(96, 64, 64)", +"hwb(360 25% 62.5%)", "rgb(96, 64, 64)", +"hwb(360deg 25% 62.5% / 0)", "rgba(96, 64, 64, 0)", +"hwb(360 25% 62.5% / 0)", "rgba(96, 64, 64, 0)", +"hwb(360deg 25% 62.5% / 0.2)", "rgba(96, 64, 64, 0.2)", +"hwb(360 25% 62.5% / 0.2)", "rgba(96, 64, 64, 0.2)", +"hwb(360deg 25% 62.5% / 1)", "rgb(96, 64, 64)", +"hwb(360 25% 62.5% / 1)", "rgb(96, 64, 64)", +"hwb(360deg 25% 75%)", "rgb(64, 64, 64)", +"hwb(360 25% 75%)", "rgb(64, 64, 64)", +"hwb(360deg 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(360 25% 75% / 0)", "rgba(64, 64, 64, 0)", +"hwb(360deg 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(360 25% 75% / 0.2)", "rgba(64, 64, 64, 0.2)", +"hwb(360deg 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(360 25% 75% / 1)", "rgb(64, 64, 64)", +"hwb(360deg 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(360 25% 87.5%)", "rgb(57, 57, 57)", +"hwb(360deg 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(360 25% 87.5% / 0)", "rgba(57, 57, 57, 0)", +"hwb(360deg 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(360 25% 87.5% / 0.2)", "rgba(57, 57, 57, 0.2)", +"hwb(360deg 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(360 25% 87.5% / 1)", "rgb(57, 57, 57)", +"hwb(360deg 25% 100%)", "rgb(51, 51, 51)", +"hwb(360 25% 100%)", "rgb(51, 51, 51)", +"hwb(360deg 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(360 25% 100% / 0)", "rgba(51, 51, 51, 0)", +"hwb(360deg 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(360 25% 100% / 0.2)", "rgba(51, 51, 51, 0.2)", +"hwb(360deg 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(360 25% 100% / 1)", "rgb(51, 51, 51)", +"hwb(360deg 37.5% 0%)", "rgb(255, 96, 96)", +"hwb(360 37.5% 0%)", "rgb(255, 96, 96)", +"hwb(360deg 37.5% 0% / 0)", "rgba(255, 96, 96, 0)", +"hwb(360 37.5% 0% / 0)", "rgba(255, 96, 96, 0)", +"hwb(360deg 37.5% 0% / 0.2)", "rgba(255, 96, 96, 0.2)", +"hwb(360 37.5% 0% / 0.2)", "rgba(255, 96, 96, 0.2)", +"hwb(360deg 37.5% 0% / 1)", "rgb(255, 96, 96)", +"hwb(360 37.5% 0% / 1)", "rgb(255, 96, 96)", +"hwb(360deg 37.5% 12.5%)", "rgb(223, 96, 96)", +"hwb(360 37.5% 12.5%)", "rgb(223, 96, 96)", +"hwb(360deg 37.5% 12.5% / 0)", "rgba(223, 96, 96, 0)", +"hwb(360 37.5% 12.5% / 0)", "rgba(223, 96, 96, 0)", +"hwb(360deg 37.5% 12.5% / 0.2)", "rgba(223, 96, 96, 0.2)", +"hwb(360 37.5% 12.5% / 0.2)", "rgba(223, 96, 96, 0.2)", +"hwb(360deg 37.5% 12.5% / 1)", "rgb(223, 96, 96)", +"hwb(360 37.5% 12.5% / 1)", "rgb(223, 96, 96)", +"hwb(360deg 37.5% 25%)", "rgb(191, 96, 96)", +"hwb(360 37.5% 25%)", "rgb(191, 96, 96)", +"hwb(360deg 37.5% 25% / 0)", "rgba(191, 96, 96, 0)", +"hwb(360 37.5% 25% / 0)", "rgba(191, 96, 96, 0)", +"hwb(360deg 37.5% 25% / 0.2)", "rgba(191, 96, 96, 0.2)", +"hwb(360 37.5% 25% / 0.2)", "rgba(191, 96, 96, 0.2)", +"hwb(360deg 37.5% 25% / 1)", "rgb(191, 96, 96)", +"hwb(360 37.5% 25% / 1)", "rgb(191, 96, 96)", +"hwb(360deg 37.5% 37.5%)", "rgb(159, 96, 96)", +"hwb(360 37.5% 37.5%)", "rgb(159, 96, 96)", +"hwb(360deg 37.5% 37.5% / 0)", "rgba(159, 96, 96, 0)", +"hwb(360 37.5% 37.5% / 0)", "rgba(159, 96, 96, 0)", +"hwb(360deg 37.5% 37.5% / 0.2)", "rgba(159, 96, 96, 0.2)", +"hwb(360 37.5% 37.5% / 0.2)", "rgba(159, 96, 96, 0.2)", +"hwb(360deg 37.5% 37.5% / 1)", "rgb(159, 96, 96)", +"hwb(360 37.5% 37.5% / 1)", "rgb(159, 96, 96)", +"hwb(360deg 37.5% 50%)", "rgb(128, 96, 96)", +"hwb(360 37.5% 50%)", "rgb(128, 96, 96)", +"hwb(360deg 37.5% 50% / 0)", "rgba(128, 96, 96, 0)", +"hwb(360 37.5% 50% / 0)", "rgba(128, 96, 96, 0)", +"hwb(360deg 37.5% 50% / 0.2)", "rgba(128, 96, 96, 0.2)", +"hwb(360 37.5% 50% / 0.2)", "rgba(128, 96, 96, 0.2)", +"hwb(360deg 37.5% 50% / 1)", "rgb(128, 96, 96)", +"hwb(360 37.5% 50% / 1)", "rgb(128, 96, 96)", +"hwb(360deg 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(360 37.5% 62.5%)", "rgb(96, 96, 96)", +"hwb(360deg 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(360 37.5% 62.5% / 0)", "rgba(96, 96, 96, 0)", +"hwb(360deg 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(360 37.5% 62.5% / 0.2)", "rgba(96, 96, 96, 0.2)", +"hwb(360deg 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(360 37.5% 62.5% / 1)", "rgb(96, 96, 96)", +"hwb(360deg 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(360 37.5% 75%)", "rgb(85, 85, 85)", +"hwb(360deg 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(360 37.5% 75% / 0)", "rgba(85, 85, 85, 0)", +"hwb(360deg 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(360 37.5% 75% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(360deg 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(360 37.5% 75% / 1)", "rgb(85, 85, 85)", +"hwb(360deg 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(360 37.5% 87.5%)", "rgb(77, 77, 77)", +"hwb(360deg 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(360 37.5% 87.5% / 0)", "rgba(77, 77, 77, 0)", +"hwb(360deg 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(360 37.5% 87.5% / 0.2)", "rgba(77, 77, 77, 0.2)", +"hwb(360deg 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(360 37.5% 87.5% / 1)", "rgb(77, 77, 77)", +"hwb(360deg 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(360 37.5% 100%)", "rgb(70, 70, 70)", +"hwb(360deg 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(360 37.5% 100% / 0)", "rgba(70, 70, 70, 0)", +"hwb(360deg 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(360 37.5% 100% / 0.2)", "rgba(70, 70, 70, 0.2)", +"hwb(360deg 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(360 37.5% 100% / 1)", "rgb(70, 70, 70)", +"hwb(360deg 50% 0%)", "rgb(255, 128, 128)", +"hwb(360 50% 0%)", "rgb(255, 128, 128)", +"hwb(360deg 50% 0% / 0)", "rgba(255, 128, 128, 0)", +"hwb(360 50% 0% / 0)", "rgba(255, 128, 128, 0)", +"hwb(360deg 50% 0% / 0.2)", "rgba(255, 128, 128, 0.2)", +"hwb(360 50% 0% / 0.2)", "rgba(255, 128, 128, 0.2)", +"hwb(360deg 50% 0% / 1)", "rgb(255, 128, 128)", +"hwb(360 50% 0% / 1)", "rgb(255, 128, 128)", +"hwb(360deg 50% 12.5%)", "rgb(223, 128, 128)", +"hwb(360 50% 12.5%)", "rgb(223, 128, 128)", +"hwb(360deg 50% 12.5% / 0)", "rgba(223, 128, 128, 0)", +"hwb(360 50% 12.5% / 0)", "rgba(223, 128, 128, 0)", +"hwb(360deg 50% 12.5% / 0.2)", "rgba(223, 128, 128, 0.2)", +"hwb(360 50% 12.5% / 0.2)", "rgba(223, 128, 128, 0.2)", +"hwb(360deg 50% 12.5% / 1)", "rgb(223, 128, 128)", +"hwb(360 50% 12.5% / 1)", "rgb(223, 128, 128)", +"hwb(360deg 50% 25%)", "rgb(191, 128, 128)", +"hwb(360 50% 25%)", "rgb(191, 128, 128)", +"hwb(360deg 50% 25% / 0)", "rgba(191, 128, 128, 0)", +"hwb(360 50% 25% / 0)", "rgba(191, 128, 128, 0)", +"hwb(360deg 50% 25% / 0.2)", "rgba(191, 128, 128, 0.2)", +"hwb(360 50% 25% / 0.2)", "rgba(191, 128, 128, 0.2)", +"hwb(360deg 50% 25% / 1)", "rgb(191, 128, 128)", +"hwb(360 50% 25% / 1)", "rgb(191, 128, 128)", +"hwb(360deg 50% 37.5%)", "rgb(159, 128, 128)", +"hwb(360 50% 37.5%)", "rgb(159, 128, 128)", +"hwb(360deg 50% 37.5% / 0)", "rgba(159, 128, 128, 0)", +"hwb(360 50% 37.5% / 0)", "rgba(159, 128, 128, 0)", +"hwb(360deg 50% 37.5% / 0.2)", "rgba(159, 128, 128, 0.2)", +"hwb(360 50% 37.5% / 0.2)", "rgba(159, 128, 128, 0.2)", +"hwb(360deg 50% 37.5% / 1)", "rgb(159, 128, 128)", +"hwb(360 50% 37.5% / 1)", "rgb(159, 128, 128)", +"hwb(360deg 50% 50%)", "rgb(128, 128, 128)", +"hwb(360 50% 50%)", "rgb(128, 128, 128)", +"hwb(360deg 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360 50% 50% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360deg 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360 50% 50% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360deg 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(360 50% 50% / 1)", "rgb(128, 128, 128)", +"hwb(360deg 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(360 50% 62.5%)", "rgb(113, 113, 113)", +"hwb(360deg 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(360 50% 62.5% / 0)", "rgba(113, 113, 113, 0)", +"hwb(360deg 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(360 50% 62.5% / 0.2)", "rgba(113, 113, 113, 0.2)", +"hwb(360deg 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(360 50% 62.5% / 1)", "rgb(113, 113, 113)", +"hwb(360deg 50% 75%)", "rgb(102, 102, 102)", +"hwb(360 50% 75%)", "rgb(102, 102, 102)", +"hwb(360deg 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(360 50% 75% / 0)", "rgba(102, 102, 102, 0)", +"hwb(360deg 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(360 50% 75% / 0.2)", "rgba(102, 102, 102, 0.2)", +"hwb(360deg 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(360 50% 75% / 1)", "rgb(102, 102, 102)", +"hwb(360deg 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(360 50% 87.5%)", "rgb(93, 93, 93)", +"hwb(360deg 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(360 50% 87.5% / 0)", "rgba(93, 93, 93, 0)", +"hwb(360deg 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(360 50% 87.5% / 0.2)", "rgba(93, 93, 93, 0.2)", +"hwb(360deg 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(360 50% 87.5% / 1)", "rgb(93, 93, 93)", +"hwb(360deg 50% 100%)", "rgb(85, 85, 85)", +"hwb(360 50% 100%)", "rgb(85, 85, 85)", +"hwb(360deg 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(360 50% 100% / 0)", "rgba(85, 85, 85, 0)", +"hwb(360deg 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(360 50% 100% / 0.2)", "rgba(85, 85, 85, 0.2)", +"hwb(360deg 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(360 50% 100% / 1)", "rgb(85, 85, 85)", +"hwb(360deg 62.5% 0%)", "rgb(255, 159, 159)", +"hwb(360 62.5% 0%)", "rgb(255, 159, 159)", +"hwb(360deg 62.5% 0% / 0)", "rgba(255, 159, 159, 0)", +"hwb(360 62.5% 0% / 0)", "rgba(255, 159, 159, 0)", +"hwb(360deg 62.5% 0% / 0.2)", "rgba(255, 159, 159, 0.2)", +"hwb(360 62.5% 0% / 0.2)", "rgba(255, 159, 159, 0.2)", +"hwb(360deg 62.5% 0% / 1)", "rgb(255, 159, 159)", +"hwb(360 62.5% 0% / 1)", "rgb(255, 159, 159)", +"hwb(360deg 62.5% 12.5%)", "rgb(223, 159, 159)", +"hwb(360 62.5% 12.5%)", "rgb(223, 159, 159)", +"hwb(360deg 62.5% 12.5% / 0)", "rgba(223, 159, 159, 0)", +"hwb(360 62.5% 12.5% / 0)", "rgba(223, 159, 159, 0)", +"hwb(360deg 62.5% 12.5% / 0.2)", "rgba(223, 159, 159, 0.2)", +"hwb(360 62.5% 12.5% / 0.2)", "rgba(223, 159, 159, 0.2)", +"hwb(360deg 62.5% 12.5% / 1)", "rgb(223, 159, 159)", +"hwb(360 62.5% 12.5% / 1)", "rgb(223, 159, 159)", +"hwb(360deg 62.5% 25%)", "rgb(191, 159, 159)", +"hwb(360 62.5% 25%)", "rgb(191, 159, 159)", +"hwb(360deg 62.5% 25% / 0)", "rgba(191, 159, 159, 0)", +"hwb(360 62.5% 25% / 0)", "rgba(191, 159, 159, 0)", +"hwb(360deg 62.5% 25% / 0.2)", "rgba(191, 159, 159, 0.2)", +"hwb(360 62.5% 25% / 0.2)", "rgba(191, 159, 159, 0.2)", +"hwb(360deg 62.5% 25% / 1)", "rgb(191, 159, 159)", +"hwb(360 62.5% 25% / 1)", "rgb(191, 159, 159)", +"hwb(360deg 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(360 62.5% 37.5%)", "rgb(159, 159, 159)", +"hwb(360deg 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(360 62.5% 37.5% / 0)", "rgba(159, 159, 159, 0)", +"hwb(360deg 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(360 62.5% 37.5% / 0.2)", "rgba(159, 159, 159, 0.2)", +"hwb(360deg 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(360 62.5% 37.5% / 1)", "rgb(159, 159, 159)", +"hwb(360deg 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(360 62.5% 50%)", "rgb(142, 142, 142)", +"hwb(360deg 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(360 62.5% 50% / 0)", "rgba(142, 142, 142, 0)", +"hwb(360deg 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(360 62.5% 50% / 0.2)", "rgba(142, 142, 142, 0.2)", +"hwb(360deg 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(360 62.5% 50% / 1)", "rgb(142, 142, 142)", +"hwb(360deg 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(360 62.5% 62.5%)", "rgb(128, 128, 128)", +"hwb(360deg 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360 62.5% 62.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360deg 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360 62.5% 62.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360deg 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(360 62.5% 62.5% / 1)", "rgb(128, 128, 128)", +"hwb(360deg 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(360 62.5% 75%)", "rgb(116, 116, 116)", +"hwb(360deg 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(360 62.5% 75% / 0)", "rgba(116, 116, 116, 0)", +"hwb(360deg 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(360 62.5% 75% / 0.2)", "rgba(116, 116, 116, 0.2)", +"hwb(360deg 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(360 62.5% 75% / 1)", "rgb(116, 116, 116)", +"hwb(360deg 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(360 62.5% 87.5%)", "rgb(106, 106, 106)", +"hwb(360deg 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(360 62.5% 87.5% / 0)", "rgba(106, 106, 106, 0)", +"hwb(360deg 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(360 62.5% 87.5% / 0.2)", "rgba(106, 106, 106, 0.2)", +"hwb(360deg 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(360 62.5% 87.5% / 1)", "rgb(106, 106, 106)", +"hwb(360deg 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(360 62.5% 100%)", "rgb(98, 98, 98)", +"hwb(360deg 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(360 62.5% 100% / 0)", "rgba(98, 98, 98, 0)", +"hwb(360deg 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(360 62.5% 100% / 0.2)", "rgba(98, 98, 98, 0.2)", +"hwb(360deg 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(360 62.5% 100% / 1)", "rgb(98, 98, 98)", +"hwb(360deg 75% 0%)", "rgb(255, 191, 191)", +"hwb(360 75% 0%)", "rgb(255, 191, 191)", +"hwb(360deg 75% 0% / 0)", "rgba(255, 191, 191, 0)", +"hwb(360 75% 0% / 0)", "rgba(255, 191, 191, 0)", +"hwb(360deg 75% 0% / 0.2)", "rgba(255, 191, 191, 0.2)", +"hwb(360 75% 0% / 0.2)", "rgba(255, 191, 191, 0.2)", +"hwb(360deg 75% 0% / 1)", "rgb(255, 191, 191)", +"hwb(360 75% 0% / 1)", "rgb(255, 191, 191)", +"hwb(360deg 75% 12.5%)", "rgb(223, 191, 191)", +"hwb(360 75% 12.5%)", "rgb(223, 191, 191)", +"hwb(360deg 75% 12.5% / 0)", "rgba(223, 191, 191, 0)", +"hwb(360 75% 12.5% / 0)", "rgba(223, 191, 191, 0)", +"hwb(360deg 75% 12.5% / 0.2)", "rgba(223, 191, 191, 0.2)", +"hwb(360 75% 12.5% / 0.2)", "rgba(223, 191, 191, 0.2)", +"hwb(360deg 75% 12.5% / 1)", "rgb(223, 191, 191)", +"hwb(360 75% 12.5% / 1)", "rgb(223, 191, 191)", +"hwb(360deg 75% 25%)", "rgb(191, 191, 191)", +"hwb(360 75% 25%)", "rgb(191, 191, 191)", +"hwb(360deg 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(360 75% 25% / 0)", "rgba(191, 191, 191, 0)", +"hwb(360deg 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(360 75% 25% / 0.2)", "rgba(191, 191, 191, 0.2)", +"hwb(360deg 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(360 75% 25% / 1)", "rgb(191, 191, 191)", +"hwb(360deg 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(360 75% 37.5%)", "rgb(170, 170, 170)", +"hwb(360deg 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(360 75% 37.5% / 0)", "rgba(170, 170, 170, 0)", +"hwb(360deg 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(360 75% 37.5% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(360deg 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(360 75% 37.5% / 1)", "rgb(170, 170, 170)", +"hwb(360deg 75% 50%)", "rgb(153, 153, 153)", +"hwb(360 75% 50%)", "rgb(153, 153, 153)", +"hwb(360deg 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(360 75% 50% / 0)", "rgba(153, 153, 153, 0)", +"hwb(360deg 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(360 75% 50% / 0.2)", "rgba(153, 153, 153, 0.2)", +"hwb(360deg 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(360 75% 50% / 1)", "rgb(153, 153, 153)", +"hwb(360deg 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(360 75% 62.5%)", "rgb(139, 139, 139)", +"hwb(360deg 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(360 75% 62.5% / 0)", "rgba(139, 139, 139, 0)", +"hwb(360deg 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(360 75% 62.5% / 0.2)", "rgba(139, 139, 139, 0.2)", +"hwb(360deg 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(360 75% 62.5% / 1)", "rgb(139, 139, 139)", +"hwb(360deg 75% 75%)", "rgb(128, 128, 128)", +"hwb(360 75% 75%)", "rgb(128, 128, 128)", +"hwb(360deg 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360 75% 75% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360deg 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360 75% 75% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360deg 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(360 75% 75% / 1)", "rgb(128, 128, 128)", +"hwb(360deg 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(360 75% 87.5%)", "rgb(118, 118, 118)", +"hwb(360deg 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(360 75% 87.5% / 0)", "rgba(118, 118, 118, 0)", +"hwb(360deg 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(360 75% 87.5% / 0.2)", "rgba(118, 118, 118, 0.2)", +"hwb(360deg 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(360 75% 87.5% / 1)", "rgb(118, 118, 118)", +"hwb(360deg 75% 100%)", "rgb(109, 109, 109)", +"hwb(360 75% 100%)", "rgb(109, 109, 109)", +"hwb(360deg 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(360 75% 100% / 0)", "rgba(109, 109, 109, 0)", +"hwb(360deg 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(360 75% 100% / 0.2)", "rgba(109, 109, 109, 0.2)", +"hwb(360deg 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(360 75% 100% / 1)", "rgb(109, 109, 109)", +"hwb(360deg 87.5% 0%)", "rgb(255, 223, 223)", +"hwb(360 87.5% 0%)", "rgb(255, 223, 223)", +"hwb(360deg 87.5% 0% / 0)", "rgba(255, 223, 223, 0)", +"hwb(360 87.5% 0% / 0)", "rgba(255, 223, 223, 0)", +"hwb(360deg 87.5% 0% / 0.2)", "rgba(255, 223, 223, 0.2)", +"hwb(360 87.5% 0% / 0.2)", "rgba(255, 223, 223, 0.2)", +"hwb(360deg 87.5% 0% / 1)", "rgb(255, 223, 223)", +"hwb(360 87.5% 0% / 1)", "rgb(255, 223, 223)", +"hwb(360deg 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(360 87.5% 12.5%)", "rgb(223, 223, 223)", +"hwb(360deg 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(360 87.5% 12.5% / 0)", "rgba(223, 223, 223, 0)", +"hwb(360deg 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(360 87.5% 12.5% / 0.2)", "rgba(223, 223, 223, 0.2)", +"hwb(360deg 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(360 87.5% 12.5% / 1)", "rgb(223, 223, 223)", +"hwb(360deg 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(360 87.5% 25%)", "rgb(198, 198, 198)", +"hwb(360deg 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(360 87.5% 25% / 0)", "rgba(198, 198, 198, 0)", +"hwb(360deg 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(360 87.5% 25% / 0.2)", "rgba(198, 198, 198, 0.2)", +"hwb(360deg 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(360 87.5% 25% / 1)", "rgb(198, 198, 198)", +"hwb(360deg 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(360 87.5% 37.5%)", "rgb(179, 179, 179)", +"hwb(360deg 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(360 87.5% 37.5% / 0)", "rgba(179, 179, 179, 0)", +"hwb(360deg 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(360 87.5% 37.5% / 0.2)", "rgba(179, 179, 179, 0.2)", +"hwb(360deg 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(360 87.5% 37.5% / 1)", "rgb(179, 179, 179)", +"hwb(360deg 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(360 87.5% 50%)", "rgb(162, 162, 162)", +"hwb(360deg 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(360 87.5% 50% / 0)", "rgba(162, 162, 162, 0)", +"hwb(360deg 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(360 87.5% 50% / 0.2)", "rgba(162, 162, 162, 0.2)", +"hwb(360deg 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(360 87.5% 50% / 1)", "rgb(162, 162, 162)", +"hwb(360deg 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(360 87.5% 62.5%)", "rgb(149, 149, 149)", +"hwb(360deg 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(360 87.5% 62.5% / 0)", "rgba(149, 149, 149, 0)", +"hwb(360deg 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(360 87.5% 62.5% / 0.2)", "rgba(149, 149, 149, 0.2)", +"hwb(360deg 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(360 87.5% 62.5% / 1)", "rgb(149, 149, 149)", +"hwb(360deg 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(360 87.5% 75%)", "rgb(137, 137, 137)", +"hwb(360deg 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(360 87.5% 75% / 0)", "rgba(137, 137, 137, 0)", +"hwb(360deg 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(360 87.5% 75% / 0.2)", "rgba(137, 137, 137, 0.2)", +"hwb(360deg 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(360 87.5% 75% / 1)", "rgb(137, 137, 137)", +"hwb(360deg 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(360 87.5% 87.5%)", "rgb(128, 128, 128)", +"hwb(360deg 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360 87.5% 87.5% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360deg 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360 87.5% 87.5% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360deg 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(360 87.5% 87.5% / 1)", "rgb(128, 128, 128)", +"hwb(360deg 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(360 87.5% 100%)", "rgb(119, 119, 119)", +"hwb(360deg 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(360 87.5% 100% / 0)", "rgba(119, 119, 119, 0)", +"hwb(360deg 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(360 87.5% 100% / 0.2)", "rgba(119, 119, 119, 0.2)", +"hwb(360deg 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(360 87.5% 100% / 1)", "rgb(119, 119, 119)", +"hwb(360deg 100% 0%)", "rgb(255, 255, 255)", +"hwb(360 100% 0%)", "rgb(255, 255, 255)", +"hwb(360deg 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(360 100% 0% / 0)", "rgba(255, 255, 255, 0)", +"hwb(360deg 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(360 100% 0% / 0.2)", "rgba(255, 255, 255, 0.2)", +"hwb(360deg 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(360 100% 0% / 1)", "rgb(255, 255, 255)", +"hwb(360deg 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(360 100% 12.5%)", "rgb(227, 227, 227)", +"hwb(360deg 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(360 100% 12.5% / 0)", "rgba(227, 227, 227, 0)", +"hwb(360deg 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(360 100% 12.5% / 0.2)", "rgba(227, 227, 227, 0.2)", +"hwb(360deg 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(360 100% 12.5% / 1)", "rgb(227, 227, 227)", +"hwb(360deg 100% 25%)", "rgb(204, 204, 204)", +"hwb(360 100% 25%)", "rgb(204, 204, 204)", +"hwb(360deg 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(360 100% 25% / 0)", "rgba(204, 204, 204, 0)", +"hwb(360deg 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(360 100% 25% / 0.2)", "rgba(204, 204, 204, 0.2)", +"hwb(360deg 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(360 100% 25% / 1)", "rgb(204, 204, 204)", +"hwb(360deg 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(360 100% 37.5%)", "rgb(185, 185, 185)", +"hwb(360deg 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(360 100% 37.5% / 0)", "rgba(185, 185, 185, 0)", +"hwb(360deg 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(360 100% 37.5% / 0.2)", "rgba(185, 185, 185, 0.2)", +"hwb(360deg 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(360 100% 37.5% / 1)", "rgb(185, 185, 185)", +"hwb(360deg 100% 50%)", "rgb(170, 170, 170)", +"hwb(360 100% 50%)", "rgb(170, 170, 170)", +"hwb(360deg 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(360 100% 50% / 0)", "rgba(170, 170, 170, 0)", +"hwb(360deg 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(360 100% 50% / 0.2)", "rgba(170, 170, 170, 0.2)", +"hwb(360deg 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(360 100% 50% / 1)", "rgb(170, 170, 170)", +"hwb(360deg 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(360 100% 62.5%)", "rgb(157, 157, 157)", +"hwb(360deg 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(360 100% 62.5% / 0)", "rgba(157, 157, 157, 0)", +"hwb(360deg 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(360 100% 62.5% / 0.2)", "rgba(157, 157, 157, 0.2)", +"hwb(360deg 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(360 100% 62.5% / 1)", "rgb(157, 157, 157)", +"hwb(360deg 100% 75%)", "rgb(146, 146, 146)", +"hwb(360 100% 75%)", "rgb(146, 146, 146)", +"hwb(360deg 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(360 100% 75% / 0)", "rgba(146, 146, 146, 0)", +"hwb(360deg 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(360 100% 75% / 0.2)", "rgba(146, 146, 146, 0.2)", +"hwb(360deg 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(360 100% 75% / 1)", "rgb(146, 146, 146)", +"hwb(360deg 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(360 100% 87.5%)", "rgb(136, 136, 136)", +"hwb(360deg 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(360 100% 87.5% / 0)", "rgba(136, 136, 136, 0)", +"hwb(360deg 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(360 100% 87.5% / 0.2)", "rgba(136, 136, 136, 0.2)", +"hwb(360deg 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(360 100% 87.5% / 1)", "rgb(136, 136, 136)", +"hwb(360deg 100% 100%)", "rgb(128, 128, 128)", +"hwb(360 100% 100%)", "rgb(128, 128, 128)", +"hwb(360deg 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360 100% 100% / 0)", "rgba(128, 128, 128, 0)", +"hwb(360deg 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360 100% 100% / 0.2)", "rgba(128, 128, 128, 0.2)", +"hwb(360deg 100% 100% / 1)", "rgb(128, 128, 128)", +"hwb(360 100% 100% / 1)", "rgb(128, 128, 128)" +]
diff --git a/src/css-parsing-tests/color4_lab_lch_oklab_oklch.json b/src/css-parsing-tests/color4_lab_lch_oklab_oklch.json new file mode 100644 index 0000000..ad9e3fb --- /dev/null +++ b/src/css-parsing-tests/color4_lab_lch_oklab_oklch.json
@@ -0,0 +1,4866 @@ +[ +"lab(0 0 0)", "lab(0 0 0)", +"lab(0% 0% 0%)", "lab(0 0 0)", +"lab(0 0 0 / 0)", "lab(0 0 0 / 0)", +"lab(0% 0% 0% / 0)", "lab(0 0 0 / 0)", +"lab(0 0 0 / 0.2)", "lab(0 0 0 / 0.2)", +"lab(0% 0% 0% / 0.2)", "lab(0 0 0 / 0.2)", +"lab(0 0 0 / 1)", "lab(0 0 0)", +"lab(0% 0% 0% / 1)", "lab(0 0 0)", +"lab(10 0 0)", "lab(10 0 0)", +"lab(10% 0% 0%)", "lab(10 0 0)", +"lab(10 0 0 / 0)", "lab(10 0 0 / 0)", +"lab(10% 0% 0% / 0)", "lab(10 0 0 / 0)", +"lab(10 0 0 / 0.2)", "lab(10 0 0 / 0.2)", +"lab(10% 0% 0% / 0.2)", "lab(10 0 0 / 0.2)", +"lab(10 0 0 / 1)", "lab(10 0 0)", +"lab(10% 0% 0% / 1)", "lab(10 0 0)", +"lab(110 0 0)", "lab(110 0 0)", +"lab(110% 0% 0%)", "lab(110 0 0)", +"lab(110 0 0 / 0)", "lab(110 0 0 / 0)", +"lab(110% 0% 0% / 0)", "lab(110 0 0 / 0)", +"lab(110 0 0 / 0.2)", "lab(110 0 0 / 0.2)", +"lab(110% 0% 0% / 0.2)", "lab(110 0 0 / 0.2)", +"lab(110 0 0 / 1)", "lab(110 0 0)", +"lab(110% 0% 0% / 1)", "lab(110 0 0)", +"lab(-10 0 0)", "lab(-10 0 0)", +"lab(-10% 0% 0%)", "lab(-10 0 0)", +"lab(-10 0 0 / 0)", "lab(-10 0 0 / 0)", +"lab(-10% 0% 0% / 0)", "lab(-10 0 0 / 0)", +"lab(-10 0 0 / 0.2)", "lab(-10 0 0 / 0.2)", +"lab(-10% 0% 0% / 0.2)", "lab(-10 0 0 / 0.2)", +"lab(-10 0 0 / 1)", "lab(-10 0 0)", +"lab(-10% 0% 0% / 1)", "lab(-10 0 0)", +"lab(0 10 0)", "lab(0 10 0)", +"lab(0% 10% 0%)", "lab(0 12.5 0)", +"lab(0 10 0 / 0)", "lab(0 10 0 / 0)", +"lab(0% 10% 0% / 0)", "lab(0 12.5 0 / 0)", +"lab(0 10 0 / 0.2)", "lab(0 10 0 / 0.2)", +"lab(0% 10% 0% / 0.2)", "lab(0 12.5 0 / 0.2)", +"lab(0 10 0 / 1)", "lab(0 10 0)", +"lab(0% 10% 0% / 1)", "lab(0 12.5 0)", +"lab(10 10 0)", "lab(10 10 0)", +"lab(10% 10% 0%)", "lab(10 12.5 0)", +"lab(10 10 0 / 0)", "lab(10 10 0 / 0)", +"lab(10% 10% 0% / 0)", "lab(10 12.5 0 / 0)", +"lab(10 10 0 / 0.2)", "lab(10 10 0 / 0.2)", +"lab(10% 10% 0% / 0.2)", "lab(10 12.5 0 / 0.2)", +"lab(10 10 0 / 1)", "lab(10 10 0)", +"lab(10% 10% 0% / 1)", "lab(10 12.5 0)", +"lab(110 10 0)", "lab(110 10 0)", +"lab(110% 10% 0%)", "lab(110 12.5 0)", +"lab(110 10 0 / 0)", "lab(110 10 0 / 0)", +"lab(110% 10% 0% / 0)", "lab(110 12.5 0 / 0)", +"lab(110 10 0 / 0.2)", "lab(110 10 0 / 0.2)", +"lab(110% 10% 0% / 0.2)", "lab(110 12.5 0 / 0.2)", +"lab(110 10 0 / 1)", "lab(110 10 0)", +"lab(110% 10% 0% / 1)", "lab(110 12.5 0)", +"lab(-10 10 0)", "lab(-10 10 0)", +"lab(-10% 10% 0%)", "lab(-10 12.5 0)", +"lab(-10 10 0 / 0)", "lab(-10 10 0 / 0)", +"lab(-10% 10% 0% / 0)", "lab(-10 12.5 0 / 0)", +"lab(-10 10 0 / 0.2)", "lab(-10 10 0 / 0.2)", +"lab(-10% 10% 0% / 0.2)", "lab(-10 12.5 0 / 0.2)", +"lab(-10 10 0 / 1)", "lab(-10 10 0)", +"lab(-10% 10% 0% / 1)", "lab(-10 12.5 0)", +"lab(0 110 0)", "lab(0 110 0)", +"lab(0% 110% 0%)", "lab(0 137.5 0)", +"lab(0 110 0 / 0)", "lab(0 110 0 / 0)", +"lab(0% 110% 0% / 0)", "lab(0 137.5 0 / 0)", +"lab(0 110 0 / 0.2)", "lab(0 110 0 / 0.2)", +"lab(0% 110% 0% / 0.2)", "lab(0 137.5 0 / 0.2)", +"lab(0 110 0 / 1)", "lab(0 110 0)", +"lab(0% 110% 0% / 1)", "lab(0 137.5 0)", +"lab(10 110 0)", "lab(10 110 0)", +"lab(10% 110% 0%)", "lab(10 137.5 0)", +"lab(10 110 0 / 0)", "lab(10 110 0 / 0)", +"lab(10% 110% 0% / 0)", "lab(10 137.5 0 / 0)", +"lab(10 110 0 / 0.2)", "lab(10 110 0 / 0.2)", +"lab(10% 110% 0% / 0.2)", "lab(10 137.5 0 / 0.2)", +"lab(10 110 0 / 1)", "lab(10 110 0)", +"lab(10% 110% 0% / 1)", "lab(10 137.5 0)", +"lab(110 110 0)", "lab(110 110 0)", +"lab(110% 110% 0%)", "lab(110 137.5 0)", +"lab(110 110 0 / 0)", "lab(110 110 0 / 0)", +"lab(110% 110% 0% / 0)", "lab(110 137.5 0 / 0)", +"lab(110 110 0 / 0.2)", "lab(110 110 0 / 0.2)", +"lab(110% 110% 0% / 0.2)", "lab(110 137.5 0 / 0.2)", +"lab(110 110 0 / 1)", "lab(110 110 0)", +"lab(110% 110% 0% / 1)", "lab(110 137.5 0)", +"lab(-10 110 0)", "lab(-10 110 0)", +"lab(-10% 110% 0%)", "lab(-10 137.5 0)", +"lab(-10 110 0 / 0)", "lab(-10 110 0 / 0)", +"lab(-10% 110% 0% / 0)", "lab(-10 137.5 0 / 0)", +"lab(-10 110 0 / 0.2)", "lab(-10 110 0 / 0.2)", +"lab(-10% 110% 0% / 0.2)", "lab(-10 137.5 0 / 0.2)", +"lab(-10 110 0 / 1)", "lab(-10 110 0)", +"lab(-10% 110% 0% / 1)", "lab(-10 137.5 0)", +"lab(0 -10 0)", "lab(0 -10 0)", +"lab(0% -10% 0%)", "lab(0 -12.5 0)", +"lab(0 -10 0 / 0)", "lab(0 -10 0 / 0)", +"lab(0% -10% 0% / 0)", "lab(0 -12.5 0 / 0)", +"lab(0 -10 0 / 0.2)", "lab(0 -10 0 / 0.2)", +"lab(0% -10% 0% / 0.2)", "lab(0 -12.5 0 / 0.2)", +"lab(0 -10 0 / 1)", "lab(0 -10 0)", +"lab(0% -10% 0% / 1)", "lab(0 -12.5 0)", +"lab(10 -10 0)", "lab(10 -10 0)", +"lab(10% -10% 0%)", "lab(10 -12.5 0)", +"lab(10 -10 0 / 0)", "lab(10 -10 0 / 0)", +"lab(10% -10% 0% / 0)", "lab(10 -12.5 0 / 0)", +"lab(10 -10 0 / 0.2)", "lab(10 -10 0 / 0.2)", +"lab(10% -10% 0% / 0.2)", "lab(10 -12.5 0 / 0.2)", +"lab(10 -10 0 / 1)", "lab(10 -10 0)", +"lab(10% -10% 0% / 1)", "lab(10 -12.5 0)", +"lab(110 -10 0)", "lab(110 -10 0)", +"lab(110% -10% 0%)", "lab(110 -12.5 0)", +"lab(110 -10 0 / 0)", "lab(110 -10 0 / 0)", +"lab(110% -10% 0% / 0)", "lab(110 -12.5 0 / 0)", +"lab(110 -10 0 / 0.2)", "lab(110 -10 0 / 0.2)", +"lab(110% -10% 0% / 0.2)", "lab(110 -12.5 0 / 0.2)", +"lab(110 -10 0 / 1)", "lab(110 -10 0)", +"lab(110% -10% 0% / 1)", "lab(110 -12.5 0)", +"lab(-10 -10 0)", "lab(-10 -10 0)", +"lab(-10% -10% 0%)", "lab(-10 -12.5 0)", +"lab(-10 -10 0 / 0)", "lab(-10 -10 0 / 0)", +"lab(-10% -10% 0% / 0)", "lab(-10 -12.5 0 / 0)", +"lab(-10 -10 0 / 0.2)", "lab(-10 -10 0 / 0.2)", +"lab(-10% -10% 0% / 0.2)", "lab(-10 -12.5 0 / 0.2)", +"lab(-10 -10 0 / 1)", "lab(-10 -10 0)", +"lab(-10% -10% 0% / 1)", "lab(-10 -12.5 0)", +"lab(0 0 10)", "lab(0 0 10)", +"lab(0% 0% 10%)", "lab(0 0 12.5)", +"lab(0 0 10 / 0)", "lab(0 0 10 / 0)", +"lab(0% 0% 10% / 0)", "lab(0 0 12.5 / 0)", +"lab(0 0 10 / 0.2)", "lab(0 0 10 / 0.2)", +"lab(0% 0% 10% / 0.2)", "lab(0 0 12.5 / 0.2)", +"lab(0 0 10 / 1)", "lab(0 0 10)", +"lab(0% 0% 10% / 1)", "lab(0 0 12.5)", +"lab(10 0 10)", "lab(10 0 10)", +"lab(10% 0% 10%)", "lab(10 0 12.5)", +"lab(10 0 10 / 0)", "lab(10 0 10 / 0)", +"lab(10% 0% 10% / 0)", "lab(10 0 12.5 / 0)", +"lab(10 0 10 / 0.2)", "lab(10 0 10 / 0.2)", +"lab(10% 0% 10% / 0.2)", "lab(10 0 12.5 / 0.2)", +"lab(10 0 10 / 1)", "lab(10 0 10)", +"lab(10% 0% 10% / 1)", "lab(10 0 12.5)", +"lab(110 0 10)", "lab(110 0 10)", +"lab(110% 0% 10%)", "lab(110 0 12.5)", +"lab(110 0 10 / 0)", "lab(110 0 10 / 0)", +"lab(110% 0% 10% / 0)", "lab(110 0 12.5 / 0)", +"lab(110 0 10 / 0.2)", "lab(110 0 10 / 0.2)", +"lab(110% 0% 10% / 0.2)", "lab(110 0 12.5 / 0.2)", +"lab(110 0 10 / 1)", "lab(110 0 10)", +"lab(110% 0% 10% / 1)", "lab(110 0 12.5)", +"lab(-10 0 10)", "lab(-10 0 10)", +"lab(-10% 0% 10%)", "lab(-10 0 12.5)", +"lab(-10 0 10 / 0)", "lab(-10 0 10 / 0)", +"lab(-10% 0% 10% / 0)", "lab(-10 0 12.5 / 0)", +"lab(-10 0 10 / 0.2)", "lab(-10 0 10 / 0.2)", +"lab(-10% 0% 10% / 0.2)", "lab(-10 0 12.5 / 0.2)", +"lab(-10 0 10 / 1)", "lab(-10 0 10)", +"lab(-10% 0% 10% / 1)", "lab(-10 0 12.5)", +"lab(0 10 10)", "lab(0 10 10)", +"lab(0% 10% 10%)", "lab(0 12.5 12.5)", +"lab(0 10 10 / 0)", "lab(0 10 10 / 0)", +"lab(0% 10% 10% / 0)", "lab(0 12.5 12.5 / 0)", +"lab(0 10 10 / 0.2)", "lab(0 10 10 / 0.2)", +"lab(0% 10% 10% / 0.2)", "lab(0 12.5 12.5 / 0.2)", +"lab(0 10 10 / 1)", "lab(0 10 10)", +"lab(0% 10% 10% / 1)", "lab(0 12.5 12.5)", +"lab(10 10 10)", "lab(10 10 10)", +"lab(10% 10% 10%)", "lab(10 12.5 12.5)", +"lab(10 10 10 / 0)", "lab(10 10 10 / 0)", +"lab(10% 10% 10% / 0)", "lab(10 12.5 12.5 / 0)", +"lab(10 10 10 / 0.2)", "lab(10 10 10 / 0.2)", +"lab(10% 10% 10% / 0.2)", "lab(10 12.5 12.5 / 0.2)", +"lab(10 10 10 / 1)", "lab(10 10 10)", +"lab(10% 10% 10% / 1)", "lab(10 12.5 12.5)", +"lab(110 10 10)", "lab(110 10 10)", +"lab(110% 10% 10%)", "lab(110 12.5 12.5)", +"lab(110 10 10 / 0)", "lab(110 10 10 / 0)", +"lab(110% 10% 10% / 0)", "lab(110 12.5 12.5 / 0)", +"lab(110 10 10 / 0.2)", "lab(110 10 10 / 0.2)", +"lab(110% 10% 10% / 0.2)", "lab(110 12.5 12.5 / 0.2)", +"lab(110 10 10 / 1)", "lab(110 10 10)", +"lab(110% 10% 10% / 1)", "lab(110 12.5 12.5)", +"lab(-10 10 10)", "lab(-10 10 10)", +"lab(-10% 10% 10%)", "lab(-10 12.5 12.5)", +"lab(-10 10 10 / 0)", "lab(-10 10 10 / 0)", +"lab(-10% 10% 10% / 0)", "lab(-10 12.5 12.5 / 0)", +"lab(-10 10 10 / 0.2)", "lab(-10 10 10 / 0.2)", +"lab(-10% 10% 10% / 0.2)", "lab(-10 12.5 12.5 / 0.2)", +"lab(-10 10 10 / 1)", "lab(-10 10 10)", +"lab(-10% 10% 10% / 1)", "lab(-10 12.5 12.5)", +"lab(0 110 10)", "lab(0 110 10)", +"lab(0% 110% 10%)", "lab(0 137.5 12.5)", +"lab(0 110 10 / 0)", "lab(0 110 10 / 0)", +"lab(0% 110% 10% / 0)", "lab(0 137.5 12.5 / 0)", +"lab(0 110 10 / 0.2)", "lab(0 110 10 / 0.2)", +"lab(0% 110% 10% / 0.2)", "lab(0 137.5 12.5 / 0.2)", +"lab(0 110 10 / 1)", "lab(0 110 10)", +"lab(0% 110% 10% / 1)", "lab(0 137.5 12.5)", +"lab(10 110 10)", "lab(10 110 10)", +"lab(10% 110% 10%)", "lab(10 137.5 12.5)", +"lab(10 110 10 / 0)", "lab(10 110 10 / 0)", +"lab(10% 110% 10% / 0)", "lab(10 137.5 12.5 / 0)", +"lab(10 110 10 / 0.2)", "lab(10 110 10 / 0.2)", +"lab(10% 110% 10% / 0.2)", "lab(10 137.5 12.5 / 0.2)", +"lab(10 110 10 / 1)", "lab(10 110 10)", +"lab(10% 110% 10% / 1)", "lab(10 137.5 12.5)", +"lab(110 110 10)", "lab(110 110 10)", +"lab(110% 110% 10%)", "lab(110 137.5 12.5)", +"lab(110 110 10 / 0)", "lab(110 110 10 / 0)", +"lab(110% 110% 10% / 0)", "lab(110 137.5 12.5 / 0)", +"lab(110 110 10 / 0.2)", "lab(110 110 10 / 0.2)", +"lab(110% 110% 10% / 0.2)", "lab(110 137.5 12.5 / 0.2)", +"lab(110 110 10 / 1)", "lab(110 110 10)", +"lab(110% 110% 10% / 1)", "lab(110 137.5 12.5)", +"lab(-10 110 10)", "lab(-10 110 10)", +"lab(-10% 110% 10%)", "lab(-10 137.5 12.5)", +"lab(-10 110 10 / 0)", "lab(-10 110 10 / 0)", +"lab(-10% 110% 10% / 0)", "lab(-10 137.5 12.5 / 0)", +"lab(-10 110 10 / 0.2)", "lab(-10 110 10 / 0.2)", +"lab(-10% 110% 10% / 0.2)", "lab(-10 137.5 12.5 / 0.2)", +"lab(-10 110 10 / 1)", "lab(-10 110 10)", +"lab(-10% 110% 10% / 1)", "lab(-10 137.5 12.5)", +"lab(0 -10 10)", "lab(0 -10 10)", +"lab(0% -10% 10%)", "lab(0 -12.5 12.5)", +"lab(0 -10 10 / 0)", "lab(0 -10 10 / 0)", +"lab(0% -10% 10% / 0)", "lab(0 -12.5 12.5 / 0)", +"lab(0 -10 10 / 0.2)", "lab(0 -10 10 / 0.2)", +"lab(0% -10% 10% / 0.2)", "lab(0 -12.5 12.5 / 0.2)", +"lab(0 -10 10 / 1)", "lab(0 -10 10)", +"lab(0% -10% 10% / 1)", "lab(0 -12.5 12.5)", +"lab(10 -10 10)", "lab(10 -10 10)", +"lab(10% -10% 10%)", "lab(10 -12.5 12.5)", +"lab(10 -10 10 / 0)", "lab(10 -10 10 / 0)", +"lab(10% -10% 10% / 0)", "lab(10 -12.5 12.5 / 0)", +"lab(10 -10 10 / 0.2)", "lab(10 -10 10 / 0.2)", +"lab(10% -10% 10% / 0.2)", "lab(10 -12.5 12.5 / 0.2)", +"lab(10 -10 10 / 1)", "lab(10 -10 10)", +"lab(10% -10% 10% / 1)", "lab(10 -12.5 12.5)", +"lab(110 -10 10)", "lab(110 -10 10)", +"lab(110% -10% 10%)", "lab(110 -12.5 12.5)", +"lab(110 -10 10 / 0)", "lab(110 -10 10 / 0)", +"lab(110% -10% 10% / 0)", "lab(110 -12.5 12.5 / 0)", +"lab(110 -10 10 / 0.2)", "lab(110 -10 10 / 0.2)", +"lab(110% -10% 10% / 0.2)", "lab(110 -12.5 12.5 / 0.2)", +"lab(110 -10 10 / 1)", "lab(110 -10 10)", +"lab(110% -10% 10% / 1)", "lab(110 -12.5 12.5)", +"lab(-10 -10 10)", "lab(-10 -10 10)", +"lab(-10% -10% 10%)", "lab(-10 -12.5 12.5)", +"lab(-10 -10 10 / 0)", "lab(-10 -10 10 / 0)", +"lab(-10% -10% 10% / 0)", "lab(-10 -12.5 12.5 / 0)", +"lab(-10 -10 10 / 0.2)", "lab(-10 -10 10 / 0.2)", +"lab(-10% -10% 10% / 0.2)", "lab(-10 -12.5 12.5 / 0.2)", +"lab(-10 -10 10 / 1)", "lab(-10 -10 10)", +"lab(-10% -10% 10% / 1)", "lab(-10 -12.5 12.5)", +"lab(0 0 110)", "lab(0 0 110)", +"lab(0% 0% 110%)", "lab(0 0 137.5)", +"lab(0 0 110 / 0)", "lab(0 0 110 / 0)", +"lab(0% 0% 110% / 0)", "lab(0 0 137.5 / 0)", +"lab(0 0 110 / 0.2)", "lab(0 0 110 / 0.2)", +"lab(0% 0% 110% / 0.2)", "lab(0 0 137.5 / 0.2)", +"lab(0 0 110 / 1)", "lab(0 0 110)", +"lab(0% 0% 110% / 1)", "lab(0 0 137.5)", +"lab(10 0 110)", "lab(10 0 110)", +"lab(10% 0% 110%)", "lab(10 0 137.5)", +"lab(10 0 110 / 0)", "lab(10 0 110 / 0)", +"lab(10% 0% 110% / 0)", "lab(10 0 137.5 / 0)", +"lab(10 0 110 / 0.2)", "lab(10 0 110 / 0.2)", +"lab(10% 0% 110% / 0.2)", "lab(10 0 137.5 / 0.2)", +"lab(10 0 110 / 1)", "lab(10 0 110)", +"lab(10% 0% 110% / 1)", "lab(10 0 137.5)", +"lab(110 0 110)", "lab(110 0 110)", +"lab(110% 0% 110%)", "lab(110 0 137.5)", +"lab(110 0 110 / 0)", "lab(110 0 110 / 0)", +"lab(110% 0% 110% / 0)", "lab(110 0 137.5 / 0)", +"lab(110 0 110 / 0.2)", "lab(110 0 110 / 0.2)", +"lab(110% 0% 110% / 0.2)", "lab(110 0 137.5 / 0.2)", +"lab(110 0 110 / 1)", "lab(110 0 110)", +"lab(110% 0% 110% / 1)", "lab(110 0 137.5)", +"lab(-10 0 110)", "lab(-10 0 110)", +"lab(-10% 0% 110%)", "lab(-10 0 137.5)", +"lab(-10 0 110 / 0)", "lab(-10 0 110 / 0)", +"lab(-10% 0% 110% / 0)", "lab(-10 0 137.5 / 0)", +"lab(-10 0 110 / 0.2)", "lab(-10 0 110 / 0.2)", +"lab(-10% 0% 110% / 0.2)", "lab(-10 0 137.5 / 0.2)", +"lab(-10 0 110 / 1)", "lab(-10 0 110)", +"lab(-10% 0% 110% / 1)", "lab(-10 0 137.5)", +"lab(0 10 110)", "lab(0 10 110)", +"lab(0% 10% 110%)", "lab(0 12.5 137.5)", +"lab(0 10 110 / 0)", "lab(0 10 110 / 0)", +"lab(0% 10% 110% / 0)", "lab(0 12.5 137.5 / 0)", +"lab(0 10 110 / 0.2)", "lab(0 10 110 / 0.2)", +"lab(0% 10% 110% / 0.2)", "lab(0 12.5 137.5 / 0.2)", +"lab(0 10 110 / 1)", "lab(0 10 110)", +"lab(0% 10% 110% / 1)", "lab(0 12.5 137.5)", +"lab(10 10 110)", "lab(10 10 110)", +"lab(10% 10% 110%)", "lab(10 12.5 137.5)", +"lab(10 10 110 / 0)", "lab(10 10 110 / 0)", +"lab(10% 10% 110% / 0)", "lab(10 12.5 137.5 / 0)", +"lab(10 10 110 / 0.2)", "lab(10 10 110 / 0.2)", +"lab(10% 10% 110% / 0.2)", "lab(10 12.5 137.5 / 0.2)", +"lab(10 10 110 / 1)", "lab(10 10 110)", +"lab(10% 10% 110% / 1)", "lab(10 12.5 137.5)", +"lab(110 10 110)", "lab(110 10 110)", +"lab(110% 10% 110%)", "lab(110 12.5 137.5)", +"lab(110 10 110 / 0)", "lab(110 10 110 / 0)", +"lab(110% 10% 110% / 0)", "lab(110 12.5 137.5 / 0)", +"lab(110 10 110 / 0.2)", "lab(110 10 110 / 0.2)", +"lab(110% 10% 110% / 0.2)", "lab(110 12.5 137.5 / 0.2)", +"lab(110 10 110 / 1)", "lab(110 10 110)", +"lab(110% 10% 110% / 1)", "lab(110 12.5 137.5)", +"lab(-10 10 110)", "lab(-10 10 110)", +"lab(-10% 10% 110%)", "lab(-10 12.5 137.5)", +"lab(-10 10 110 / 0)", "lab(-10 10 110 / 0)", +"lab(-10% 10% 110% / 0)", "lab(-10 12.5 137.5 / 0)", +"lab(-10 10 110 / 0.2)", "lab(-10 10 110 / 0.2)", +"lab(-10% 10% 110% / 0.2)", "lab(-10 12.5 137.5 / 0.2)", +"lab(-10 10 110 / 1)", "lab(-10 10 110)", +"lab(-10% 10% 110% / 1)", "lab(-10 12.5 137.5)", +"lab(0 110 110)", "lab(0 110 110)", +"lab(0% 110% 110%)", "lab(0 137.5 137.5)", +"lab(0 110 110 / 0)", "lab(0 110 110 / 0)", +"lab(0% 110% 110% / 0)", "lab(0 137.5 137.5 / 0)", +"lab(0 110 110 / 0.2)", "lab(0 110 110 / 0.2)", +"lab(0% 110% 110% / 0.2)", "lab(0 137.5 137.5 / 0.2)", +"lab(0 110 110 / 1)", "lab(0 110 110)", +"lab(0% 110% 110% / 1)", "lab(0 137.5 137.5)", +"lab(10 110 110)", "lab(10 110 110)", +"lab(10% 110% 110%)", "lab(10 137.5 137.5)", +"lab(10 110 110 / 0)", "lab(10 110 110 / 0)", +"lab(10% 110% 110% / 0)", "lab(10 137.5 137.5 / 0)", +"lab(10 110 110 / 0.2)", "lab(10 110 110 / 0.2)", +"lab(10% 110% 110% / 0.2)", "lab(10 137.5 137.5 / 0.2)", +"lab(10 110 110 / 1)", "lab(10 110 110)", +"lab(10% 110% 110% / 1)", "lab(10 137.5 137.5)", +"lab(110 110 110)", "lab(110 110 110)", +"lab(110% 110% 110%)", "lab(110 137.5 137.5)", +"lab(110 110 110 / 0)", "lab(110 110 110 / 0)", +"lab(110% 110% 110% / 0)", "lab(110 137.5 137.5 / 0)", +"lab(110 110 110 / 0.2)", "lab(110 110 110 / 0.2)", +"lab(110% 110% 110% / 0.2)", "lab(110 137.5 137.5 / 0.2)", +"lab(110 110 110 / 1)", "lab(110 110 110)", +"lab(110% 110% 110% / 1)", "lab(110 137.5 137.5)", +"lab(-10 110 110)", "lab(-10 110 110)", +"lab(-10% 110% 110%)", "lab(-10 137.5 137.5)", +"lab(-10 110 110 / 0)", "lab(-10 110 110 / 0)", +"lab(-10% 110% 110% / 0)", "lab(-10 137.5 137.5 / 0)", +"lab(-10 110 110 / 0.2)", "lab(-10 110 110 / 0.2)", +"lab(-10% 110% 110% / 0.2)", "lab(-10 137.5 137.5 / 0.2)", +"lab(-10 110 110 / 1)", "lab(-10 110 110)", +"lab(-10% 110% 110% / 1)", "lab(-10 137.5 137.5)", +"lab(0 -10 110)", "lab(0 -10 110)", +"lab(0% -10% 110%)", "lab(0 -12.5 137.5)", +"lab(0 -10 110 / 0)", "lab(0 -10 110 / 0)", +"lab(0% -10% 110% / 0)", "lab(0 -12.5 137.5 / 0)", +"lab(0 -10 110 / 0.2)", "lab(0 -10 110 / 0.2)", +"lab(0% -10% 110% / 0.2)", "lab(0 -12.5 137.5 / 0.2)", +"lab(0 -10 110 / 1)", "lab(0 -10 110)", +"lab(0% -10% 110% / 1)", "lab(0 -12.5 137.5)", +"lab(10 -10 110)", "lab(10 -10 110)", +"lab(10% -10% 110%)", "lab(10 -12.5 137.5)", +"lab(10 -10 110 / 0)", "lab(10 -10 110 / 0)", +"lab(10% -10% 110% / 0)", "lab(10 -12.5 137.5 / 0)", +"lab(10 -10 110 / 0.2)", "lab(10 -10 110 / 0.2)", +"lab(10% -10% 110% / 0.2)", "lab(10 -12.5 137.5 / 0.2)", +"lab(10 -10 110 / 1)", "lab(10 -10 110)", +"lab(10% -10% 110% / 1)", "lab(10 -12.5 137.5)", +"lab(110 -10 110)", "lab(110 -10 110)", +"lab(110% -10% 110%)", "lab(110 -12.5 137.5)", +"lab(110 -10 110 / 0)", "lab(110 -10 110 / 0)", +"lab(110% -10% 110% / 0)", "lab(110 -12.5 137.5 / 0)", +"lab(110 -10 110 / 0.2)", "lab(110 -10 110 / 0.2)", +"lab(110% -10% 110% / 0.2)", "lab(110 -12.5 137.5 / 0.2)", +"lab(110 -10 110 / 1)", "lab(110 -10 110)", +"lab(110% -10% 110% / 1)", "lab(110 -12.5 137.5)", +"lab(-10 -10 110)", "lab(-10 -10 110)", +"lab(-10% -10% 110%)", "lab(-10 -12.5 137.5)", +"lab(-10 -10 110 / 0)", "lab(-10 -10 110 / 0)", +"lab(-10% -10% 110% / 0)", "lab(-10 -12.5 137.5 / 0)", +"lab(-10 -10 110 / 0.2)", "lab(-10 -10 110 / 0.2)", +"lab(-10% -10% 110% / 0.2)", "lab(-10 -12.5 137.5 / 0.2)", +"lab(-10 -10 110 / 1)", "lab(-10 -10 110)", +"lab(-10% -10% 110% / 1)", "lab(-10 -12.5 137.5)", +"lab(0 0 -10)", "lab(0 0 -10)", +"lab(0% 0% -10%)", "lab(0 0 -12.5)", +"lab(0 0 -10 / 0)", "lab(0 0 -10 / 0)", +"lab(0% 0% -10% / 0)", "lab(0 0 -12.5 / 0)", +"lab(0 0 -10 / 0.2)", "lab(0 0 -10 / 0.2)", +"lab(0% 0% -10% / 0.2)", "lab(0 0 -12.5 / 0.2)", +"lab(0 0 -10 / 1)", "lab(0 0 -10)", +"lab(0% 0% -10% / 1)", "lab(0 0 -12.5)", +"lab(10 0 -10)", "lab(10 0 -10)", +"lab(10% 0% -10%)", "lab(10 0 -12.5)", +"lab(10 0 -10 / 0)", "lab(10 0 -10 / 0)", +"lab(10% 0% -10% / 0)", "lab(10 0 -12.5 / 0)", +"lab(10 0 -10 / 0.2)", "lab(10 0 -10 / 0.2)", +"lab(10% 0% -10% / 0.2)", "lab(10 0 -12.5 / 0.2)", +"lab(10 0 -10 / 1)", "lab(10 0 -10)", +"lab(10% 0% -10% / 1)", "lab(10 0 -12.5)", +"lab(110 0 -10)", "lab(110 0 -10)", +"lab(110% 0% -10%)", "lab(110 0 -12.5)", +"lab(110 0 -10 / 0)", "lab(110 0 -10 / 0)", +"lab(110% 0% -10% / 0)", "lab(110 0 -12.5 / 0)", +"lab(110 0 -10 / 0.2)", "lab(110 0 -10 / 0.2)", +"lab(110% 0% -10% / 0.2)", "lab(110 0 -12.5 / 0.2)", +"lab(110 0 -10 / 1)", "lab(110 0 -10)", +"lab(110% 0% -10% / 1)", "lab(110 0 -12.5)", +"lab(-10 0 -10)", "lab(-10 0 -10)", +"lab(-10% 0% -10%)", "lab(-10 0 -12.5)", +"lab(-10 0 -10 / 0)", "lab(-10 0 -10 / 0)", +"lab(-10% 0% -10% / 0)", "lab(-10 0 -12.5 / 0)", +"lab(-10 0 -10 / 0.2)", "lab(-10 0 -10 / 0.2)", +"lab(-10% 0% -10% / 0.2)", "lab(-10 0 -12.5 / 0.2)", +"lab(-10 0 -10 / 1)", "lab(-10 0 -10)", +"lab(-10% 0% -10% / 1)", "lab(-10 0 -12.5)", +"lab(0 10 -10)", "lab(0 10 -10)", +"lab(0% 10% -10%)", "lab(0 12.5 -12.5)", +"lab(0 10 -10 / 0)", "lab(0 10 -10 / 0)", +"lab(0% 10% -10% / 0)", "lab(0 12.5 -12.5 / 0)", +"lab(0 10 -10 / 0.2)", "lab(0 10 -10 / 0.2)", +"lab(0% 10% -10% / 0.2)", "lab(0 12.5 -12.5 / 0.2)", +"lab(0 10 -10 / 1)", "lab(0 10 -10)", +"lab(0% 10% -10% / 1)", "lab(0 12.5 -12.5)", +"lab(10 10 -10)", "lab(10 10 -10)", +"lab(10% 10% -10%)", "lab(10 12.5 -12.5)", +"lab(10 10 -10 / 0)", "lab(10 10 -10 / 0)", +"lab(10% 10% -10% / 0)", "lab(10 12.5 -12.5 / 0)", +"lab(10 10 -10 / 0.2)", "lab(10 10 -10 / 0.2)", +"lab(10% 10% -10% / 0.2)", "lab(10 12.5 -12.5 / 0.2)", +"lab(10 10 -10 / 1)", "lab(10 10 -10)", +"lab(10% 10% -10% / 1)", "lab(10 12.5 -12.5)", +"lab(110 10 -10)", "lab(110 10 -10)", +"lab(110% 10% -10%)", "lab(110 12.5 -12.5)", +"lab(110 10 -10 / 0)", "lab(110 10 -10 / 0)", +"lab(110% 10% -10% / 0)", "lab(110 12.5 -12.5 / 0)", +"lab(110 10 -10 / 0.2)", "lab(110 10 -10 / 0.2)", +"lab(110% 10% -10% / 0.2)", "lab(110 12.5 -12.5 / 0.2)", +"lab(110 10 -10 / 1)", "lab(110 10 -10)", +"lab(110% 10% -10% / 1)", "lab(110 12.5 -12.5)", +"lab(-10 10 -10)", "lab(-10 10 -10)", +"lab(-10% 10% -10%)", "lab(-10 12.5 -12.5)", +"lab(-10 10 -10 / 0)", "lab(-10 10 -10 / 0)", +"lab(-10% 10% -10% / 0)", "lab(-10 12.5 -12.5 / 0)", +"lab(-10 10 -10 / 0.2)", "lab(-10 10 -10 / 0.2)", +"lab(-10% 10% -10% / 0.2)", "lab(-10 12.5 -12.5 / 0.2)", +"lab(-10 10 -10 / 1)", "lab(-10 10 -10)", +"lab(-10% 10% -10% / 1)", "lab(-10 12.5 -12.5)", +"lab(0 110 -10)", "lab(0 110 -10)", +"lab(0% 110% -10%)", "lab(0 137.5 -12.5)", +"lab(0 110 -10 / 0)", "lab(0 110 -10 / 0)", +"lab(0% 110% -10% / 0)", "lab(0 137.5 -12.5 / 0)", +"lab(0 110 -10 / 0.2)", "lab(0 110 -10 / 0.2)", +"lab(0% 110% -10% / 0.2)", "lab(0 137.5 -12.5 / 0.2)", +"lab(0 110 -10 / 1)", "lab(0 110 -10)", +"lab(0% 110% -10% / 1)", "lab(0 137.5 -12.5)", +"lab(10 110 -10)", "lab(10 110 -10)", +"lab(10% 110% -10%)", "lab(10 137.5 -12.5)", +"lab(10 110 -10 / 0)", "lab(10 110 -10 / 0)", +"lab(10% 110% -10% / 0)", "lab(10 137.5 -12.5 / 0)", +"lab(10 110 -10 / 0.2)", "lab(10 110 -10 / 0.2)", +"lab(10% 110% -10% / 0.2)", "lab(10 137.5 -12.5 / 0.2)", +"lab(10 110 -10 / 1)", "lab(10 110 -10)", +"lab(10% 110% -10% / 1)", "lab(10 137.5 -12.5)", +"lab(110 110 -10)", "lab(110 110 -10)", +"lab(110% 110% -10%)", "lab(110 137.5 -12.5)", +"lab(110 110 -10 / 0)", "lab(110 110 -10 / 0)", +"lab(110% 110% -10% / 0)", "lab(110 137.5 -12.5 / 0)", +"lab(110 110 -10 / 0.2)", "lab(110 110 -10 / 0.2)", +"lab(110% 110% -10% / 0.2)", "lab(110 137.5 -12.5 / 0.2)", +"lab(110 110 -10 / 1)", "lab(110 110 -10)", +"lab(110% 110% -10% / 1)", "lab(110 137.5 -12.5)", +"lab(-10 110 -10)", "lab(-10 110 -10)", +"lab(-10% 110% -10%)", "lab(-10 137.5 -12.5)", +"lab(-10 110 -10 / 0)", "lab(-10 110 -10 / 0)", +"lab(-10% 110% -10% / 0)", "lab(-10 137.5 -12.5 / 0)", +"lab(-10 110 -10 / 0.2)", "lab(-10 110 -10 / 0.2)", +"lab(-10% 110% -10% / 0.2)", "lab(-10 137.5 -12.5 / 0.2)", +"lab(-10 110 -10 / 1)", "lab(-10 110 -10)", +"lab(-10% 110% -10% / 1)", "lab(-10 137.5 -12.5)", +"lab(0 -10 -10)", "lab(0 -10 -10)", +"lab(0% -10% -10%)", "lab(0 -12.5 -12.5)", +"lab(0 -10 -10 / 0)", "lab(0 -10 -10 / 0)", +"lab(0% -10% -10% / 0)", "lab(0 -12.5 -12.5 / 0)", +"lab(0 -10 -10 / 0.2)", "lab(0 -10 -10 / 0.2)", +"lab(0% -10% -10% / 0.2)", "lab(0 -12.5 -12.5 / 0.2)", +"lab(0 -10 -10 / 1)", "lab(0 -10 -10)", +"lab(0% -10% -10% / 1)", "lab(0 -12.5 -12.5)", +"lab(10 -10 -10)", "lab(10 -10 -10)", +"lab(10% -10% -10%)", "lab(10 -12.5 -12.5)", +"lab(10 -10 -10 / 0)", "lab(10 -10 -10 / 0)", +"lab(10% -10% -10% / 0)", "lab(10 -12.5 -12.5 / 0)", +"lab(10 -10 -10 / 0.2)", "lab(10 -10 -10 / 0.2)", +"lab(10% -10% -10% / 0.2)", "lab(10 -12.5 -12.5 / 0.2)", +"lab(10 -10 -10 / 1)", "lab(10 -10 -10)", +"lab(10% -10% -10% / 1)", "lab(10 -12.5 -12.5)", +"lab(110 -10 -10)", "lab(110 -10 -10)", +"lab(110% -10% -10%)", "lab(110 -12.5 -12.5)", +"lab(110 -10 -10 / 0)", "lab(110 -10 -10 / 0)", +"lab(110% -10% -10% / 0)", "lab(110 -12.5 -12.5 / 0)", +"lab(110 -10 -10 / 0.2)", "lab(110 -10 -10 / 0.2)", +"lab(110% -10% -10% / 0.2)", "lab(110 -12.5 -12.5 / 0.2)", +"lab(110 -10 -10 / 1)", "lab(110 -10 -10)", +"lab(110% -10% -10% / 1)", "lab(110 -12.5 -12.5)", +"lab(-10 -10 -10)", "lab(-10 -10 -10)", +"lab(-10% -10% -10%)", "lab(-10 -12.5 -12.5)", +"lab(-10 -10 -10 / 0)", "lab(-10 -10 -10 / 0)", +"lab(-10% -10% -10% / 0)", "lab(-10 -12.5 -12.5 / 0)", +"lab(-10 -10 -10 / 0.2)", "lab(-10 -10 -10 / 0.2)", +"lab(-10% -10% -10% / 0.2)", "lab(-10 -12.5 -12.5 / 0.2)", +"lab(-10 -10 -10 / 1)", "lab(-10 -10 -10)", +"lab(-10% -10% -10% / 1)", "lab(-10 -12.5 -12.5)", +"oklab(0 0 0)", "oklab(0 0 0)", +"oklab(0% 0% 0%)", "oklab(0 0 0)", +"oklab(0 0 0 / 0)", "oklab(0 0 0 / 0)", +"oklab(0% 0% 0% / 0)", "oklab(0 0 0 / 0)", +"oklab(0 0 0 / 0.2)", "oklab(0 0 0 / 0.2)", +"oklab(0% 0% 0% / 0.2)", "oklab(0 0 0 / 0.2)", +"oklab(0 0 0 / 1)", "oklab(0 0 0)", +"oklab(0% 0% 0% / 1)", "oklab(0 0 0)", +"oklab(10 0 0)", "oklab(10 0 0)", +"oklab(10% 0% 0%)", "oklab(0.1 0 0)", +"oklab(10 0 0 / 0)", "oklab(10 0 0 / 0)", +"oklab(10% 0% 0% / 0)", "oklab(0.1 0 0 / 0)", +"oklab(10 0 0 / 0.2)", "oklab(10 0 0 / 0.2)", +"oklab(10% 0% 0% / 0.2)", "oklab(0.1 0 0 / 0.2)", +"oklab(10 0 0 / 1)", "oklab(10 0 0)", +"oklab(10% 0% 0% / 1)", "oklab(0.1 0 0)", +"oklab(110 0 0)", "oklab(110 0 0)", +"oklab(110% 0% 0%)", "oklab(1.1 0 0)", +"oklab(110 0 0 / 0)", "oklab(110 0 0 / 0)", +"oklab(110% 0% 0% / 0)", "oklab(1.1 0 0 / 0)", +"oklab(110 0 0 / 0.2)", "oklab(110 0 0 / 0.2)", +"oklab(110% 0% 0% / 0.2)", "oklab(1.1 0 0 / 0.2)", +"oklab(110 0 0 / 1)", "oklab(110 0 0)", +"oklab(110% 0% 0% / 1)", "oklab(1.1 0 0)", +"oklab(-10 0 0)", "oklab(-10 0 0)", +"oklab(-10% 0% 0%)", "oklab(-0.1 0 0)", +"oklab(-10 0 0 / 0)", "oklab(-10 0 0 / 0)", +"oklab(-10% 0% 0% / 0)", "oklab(-0.1 0 0 / 0)", +"oklab(-10 0 0 / 0.2)", "oklab(-10 0 0 / 0.2)", +"oklab(-10% 0% 0% / 0.2)", "oklab(-0.1 0 0 / 0.2)", +"oklab(-10 0 0 / 1)", "oklab(-10 0 0)", +"oklab(-10% 0% 0% / 1)", "oklab(-0.1 0 0)", +"oklab(0 10 0)", "oklab(0 10 0)", +"oklab(0% 10% 0%)", "oklab(0 0.04 0)", +"oklab(0 10 0 / 0)", "oklab(0 10 0 / 0)", +"oklab(0% 10% 0% / 0)", "oklab(0 0.04 0 / 0)", +"oklab(0 10 0 / 0.2)", "oklab(0 10 0 / 0.2)", +"oklab(0% 10% 0% / 0.2)", "oklab(0 0.04 0 / 0.2)", +"oklab(0 10 0 / 1)", "oklab(0 10 0)", +"oklab(0% 10% 0% / 1)", "oklab(0 0.04 0)", +"oklab(10 10 0)", "oklab(10 10 0)", +"oklab(10% 10% 0%)", "oklab(0.1 0.04 0)", +"oklab(10 10 0 / 0)", "oklab(10 10 0 / 0)", +"oklab(10% 10% 0% / 0)", "oklab(0.1 0.04 0 / 0)", +"oklab(10 10 0 / 0.2)", "oklab(10 10 0 / 0.2)", +"oklab(10% 10% 0% / 0.2)", "oklab(0.1 0.04 0 / 0.2)", +"oklab(10 10 0 / 1)", "oklab(10 10 0)", +"oklab(10% 10% 0% / 1)", "oklab(0.1 0.04 0)", +"oklab(110 10 0)", "oklab(110 10 0)", +"oklab(110% 10% 0%)", "oklab(1.1 0.04 0)", +"oklab(110 10 0 / 0)", "oklab(110 10 0 / 0)", +"oklab(110% 10% 0% / 0)", "oklab(1.1 0.04 0 / 0)", +"oklab(110 10 0 / 0.2)", "oklab(110 10 0 / 0.2)", +"oklab(110% 10% 0% / 0.2)", "oklab(1.1 0.04 0 / 0.2)", +"oklab(110 10 0 / 1)", "oklab(110 10 0)", +"oklab(110% 10% 0% / 1)", "oklab(1.1 0.04 0)", +"oklab(-10 10 0)", "oklab(-10 10 0)", +"oklab(-10% 10% 0%)", "oklab(-0.1 0.04 0)", +"oklab(-10 10 0 / 0)", "oklab(-10 10 0 / 0)", +"oklab(-10% 10% 0% / 0)", "oklab(-0.1 0.04 0 / 0)", +"oklab(-10 10 0 / 0.2)", "oklab(-10 10 0 / 0.2)", +"oklab(-10% 10% 0% / 0.2)", "oklab(-0.1 0.04 0 / 0.2)", +"oklab(-10 10 0 / 1)", "oklab(-10 10 0)", +"oklab(-10% 10% 0% / 1)", "oklab(-0.1 0.04 0)", +"oklab(0 110 0)", "oklab(0 110 0)", +"oklab(0% 110% 0%)", "oklab(0 0.44 0)", +"oklab(0 110 0 / 0)", "oklab(0 110 0 / 0)", +"oklab(0% 110% 0% / 0)", "oklab(0 0.44 0 / 0)", +"oklab(0 110 0 / 0.2)", "oklab(0 110 0 / 0.2)", +"oklab(0% 110% 0% / 0.2)", "oklab(0 0.44 0 / 0.2)", +"oklab(0 110 0 / 1)", "oklab(0 110 0)", +"oklab(0% 110% 0% / 1)", "oklab(0 0.44 0)", +"oklab(10 110 0)", "oklab(10 110 0)", +"oklab(10% 110% 0%)", "oklab(0.1 0.44 0)", +"oklab(10 110 0 / 0)", "oklab(10 110 0 / 0)", +"oklab(10% 110% 0% / 0)", "oklab(0.1 0.44 0 / 0)", +"oklab(10 110 0 / 0.2)", "oklab(10 110 0 / 0.2)", +"oklab(10% 110% 0% / 0.2)", "oklab(0.1 0.44 0 / 0.2)", +"oklab(10 110 0 / 1)", "oklab(10 110 0)", +"oklab(10% 110% 0% / 1)", "oklab(0.1 0.44 0)", +"oklab(110 110 0)", "oklab(110 110 0)", +"oklab(110% 110% 0%)", "oklab(1.1 0.44 0)", +"oklab(110 110 0 / 0)", "oklab(110 110 0 / 0)", +"oklab(110% 110% 0% / 0)", "oklab(1.1 0.44 0 / 0)", +"oklab(110 110 0 / 0.2)", "oklab(110 110 0 / 0.2)", +"oklab(110% 110% 0% / 0.2)", "oklab(1.1 0.44 0 / 0.2)", +"oklab(110 110 0 / 1)", "oklab(110 110 0)", +"oklab(110% 110% 0% / 1)", "oklab(1.1 0.44 0)", +"oklab(-10 110 0)", "oklab(-10 110 0)", +"oklab(-10% 110% 0%)", "oklab(-0.1 0.44 0)", +"oklab(-10 110 0 / 0)", "oklab(-10 110 0 / 0)", +"oklab(-10% 110% 0% / 0)", "oklab(-0.1 0.44 0 / 0)", +"oklab(-10 110 0 / 0.2)", "oklab(-10 110 0 / 0.2)", +"oklab(-10% 110% 0% / 0.2)", "oklab(-0.1 0.44 0 / 0.2)", +"oklab(-10 110 0 / 1)", "oklab(-10 110 0)", +"oklab(-10% 110% 0% / 1)", "oklab(-0.1 0.44 0)", +"oklab(0 -10 0)", "oklab(0 -10 0)", +"oklab(0% -10% 0%)", "oklab(0 -0.04 0)", +"oklab(0 -10 0 / 0)", "oklab(0 -10 0 / 0)", +"oklab(0% -10% 0% / 0)", "oklab(0 -0.04 0 / 0)", +"oklab(0 -10 0 / 0.2)", "oklab(0 -10 0 / 0.2)", +"oklab(0% -10% 0% / 0.2)", "oklab(0 -0.04 0 / 0.2)", +"oklab(0 -10 0 / 1)", "oklab(0 -10 0)", +"oklab(0% -10% 0% / 1)", "oklab(0 -0.04 0)", +"oklab(10 -10 0)", "oklab(10 -10 0)", +"oklab(10% -10% 0%)", "oklab(0.1 -0.04 0)", +"oklab(10 -10 0 / 0)", "oklab(10 -10 0 / 0)", +"oklab(10% -10% 0% / 0)", "oklab(0.1 -0.04 0 / 0)", +"oklab(10 -10 0 / 0.2)", "oklab(10 -10 0 / 0.2)", +"oklab(10% -10% 0% / 0.2)", "oklab(0.1 -0.04 0 / 0.2)", +"oklab(10 -10 0 / 1)", "oklab(10 -10 0)", +"oklab(10% -10% 0% / 1)", "oklab(0.1 -0.04 0)", +"oklab(110 -10 0)", "oklab(110 -10 0)", +"oklab(110% -10% 0%)", "oklab(1.1 -0.04 0)", +"oklab(110 -10 0 / 0)", "oklab(110 -10 0 / 0)", +"oklab(110% -10% 0% / 0)", "oklab(1.1 -0.04 0 / 0)", +"oklab(110 -10 0 / 0.2)", "oklab(110 -10 0 / 0.2)", +"oklab(110% -10% 0% / 0.2)", "oklab(1.1 -0.04 0 / 0.2)", +"oklab(110 -10 0 / 1)", "oklab(110 -10 0)", +"oklab(110% -10% 0% / 1)", "oklab(1.1 -0.04 0)", +"oklab(-10 -10 0)", "oklab(-10 -10 0)", +"oklab(-10% -10% 0%)", "oklab(-0.1 -0.04 0)", +"oklab(-10 -10 0 / 0)", "oklab(-10 -10 0 / 0)", +"oklab(-10% -10% 0% / 0)", "oklab(-0.1 -0.04 0 / 0)", +"oklab(-10 -10 0 / 0.2)", "oklab(-10 -10 0 / 0.2)", +"oklab(-10% -10% 0% / 0.2)", "oklab(-0.1 -0.04 0 / 0.2)", +"oklab(-10 -10 0 / 1)", "oklab(-10 -10 0)", +"oklab(-10% -10% 0% / 1)", "oklab(-0.1 -0.04 0)", +"oklab(0 0 10)", "oklab(0 0 10)", +"oklab(0% 0% 10%)", "oklab(0 0 0.04)", +"oklab(0 0 10 / 0)", "oklab(0 0 10 / 0)", +"oklab(0% 0% 10% / 0)", "oklab(0 0 0.04 / 0)", +"oklab(0 0 10 / 0.2)", "oklab(0 0 10 / 0.2)", +"oklab(0% 0% 10% / 0.2)", "oklab(0 0 0.04 / 0.2)", +"oklab(0 0 10 / 1)", "oklab(0 0 10)", +"oklab(0% 0% 10% / 1)", "oklab(0 0 0.04)", +"oklab(10 0 10)", "oklab(10 0 10)", +"oklab(10% 0% 10%)", "oklab(0.1 0 0.04)", +"oklab(10 0 10 / 0)", "oklab(10 0 10 / 0)", +"oklab(10% 0% 10% / 0)", "oklab(0.1 0 0.04 / 0)", +"oklab(10 0 10 / 0.2)", "oklab(10 0 10 / 0.2)", +"oklab(10% 0% 10% / 0.2)", "oklab(0.1 0 0.04 / 0.2)", +"oklab(10 0 10 / 1)", "oklab(10 0 10)", +"oklab(10% 0% 10% / 1)", "oklab(0.1 0 0.04)", +"oklab(110 0 10)", "oklab(110 0 10)", +"oklab(110% 0% 10%)", "oklab(1.1 0 0.04)", +"oklab(110 0 10 / 0)", "oklab(110 0 10 / 0)", +"oklab(110% 0% 10% / 0)", "oklab(1.1 0 0.04 / 0)", +"oklab(110 0 10 / 0.2)", "oklab(110 0 10 / 0.2)", +"oklab(110% 0% 10% / 0.2)", "oklab(1.1 0 0.04 / 0.2)", +"oklab(110 0 10 / 1)", "oklab(110 0 10)", +"oklab(110% 0% 10% / 1)", "oklab(1.1 0 0.04)", +"oklab(-10 0 10)", "oklab(-10 0 10)", +"oklab(-10% 0% 10%)", "oklab(-0.1 0 0.04)", +"oklab(-10 0 10 / 0)", "oklab(-10 0 10 / 0)", +"oklab(-10% 0% 10% / 0)", "oklab(-0.1 0 0.04 / 0)", +"oklab(-10 0 10 / 0.2)", "oklab(-10 0 10 / 0.2)", +"oklab(-10% 0% 10% / 0.2)", "oklab(-0.1 0 0.04 / 0.2)", +"oklab(-10 0 10 / 1)", "oklab(-10 0 10)", +"oklab(-10% 0% 10% / 1)", "oklab(-0.1 0 0.04)", +"oklab(0 10 10)", "oklab(0 10 10)", +"oklab(0% 10% 10%)", "oklab(0 0.04 0.04)", +"oklab(0 10 10 / 0)", "oklab(0 10 10 / 0)", +"oklab(0% 10% 10% / 0)", "oklab(0 0.04 0.04 / 0)", +"oklab(0 10 10 / 0.2)", "oklab(0 10 10 / 0.2)", +"oklab(0% 10% 10% / 0.2)", "oklab(0 0.04 0.04 / 0.2)", +"oklab(0 10 10 / 1)", "oklab(0 10 10)", +"oklab(0% 10% 10% / 1)", "oklab(0 0.04 0.04)", +"oklab(10 10 10)", "oklab(10 10 10)", +"oklab(10% 10% 10%)", "oklab(0.1 0.04 0.04)", +"oklab(10 10 10 / 0)", "oklab(10 10 10 / 0)", +"oklab(10% 10% 10% / 0)", "oklab(0.1 0.04 0.04 / 0)", +"oklab(10 10 10 / 0.2)", "oklab(10 10 10 / 0.2)", +"oklab(10% 10% 10% / 0.2)", "oklab(0.1 0.04 0.04 / 0.2)", +"oklab(10 10 10 / 1)", "oklab(10 10 10)", +"oklab(10% 10% 10% / 1)", "oklab(0.1 0.04 0.04)", +"oklab(110 10 10)", "oklab(110 10 10)", +"oklab(110% 10% 10%)", "oklab(1.1 0.04 0.04)", +"oklab(110 10 10 / 0)", "oklab(110 10 10 / 0)", +"oklab(110% 10% 10% / 0)", "oklab(1.1 0.04 0.04 / 0)", +"oklab(110 10 10 / 0.2)", "oklab(110 10 10 / 0.2)", +"oklab(110% 10% 10% / 0.2)", "oklab(1.1 0.04 0.04 / 0.2)", +"oklab(110 10 10 / 1)", "oklab(110 10 10)", +"oklab(110% 10% 10% / 1)", "oklab(1.1 0.04 0.04)", +"oklab(-10 10 10)", "oklab(-10 10 10)", +"oklab(-10% 10% 10%)", "oklab(-0.1 0.04 0.04)", +"oklab(-10 10 10 / 0)", "oklab(-10 10 10 / 0)", +"oklab(-10% 10% 10% / 0)", "oklab(-0.1 0.04 0.04 / 0)", +"oklab(-10 10 10 / 0.2)", "oklab(-10 10 10 / 0.2)", +"oklab(-10% 10% 10% / 0.2)", "oklab(-0.1 0.04 0.04 / 0.2)", +"oklab(-10 10 10 / 1)", "oklab(-10 10 10)", +"oklab(-10% 10% 10% / 1)", "oklab(-0.1 0.04 0.04)", +"oklab(0 110 10)", "oklab(0 110 10)", +"oklab(0% 110% 10%)", "oklab(0 0.44 0.04)", +"oklab(0 110 10 / 0)", "oklab(0 110 10 / 0)", +"oklab(0% 110% 10% / 0)", "oklab(0 0.44 0.04 / 0)", +"oklab(0 110 10 / 0.2)", "oklab(0 110 10 / 0.2)", +"oklab(0% 110% 10% / 0.2)", "oklab(0 0.44 0.04 / 0.2)", +"oklab(0 110 10 / 1)", "oklab(0 110 10)", +"oklab(0% 110% 10% / 1)", "oklab(0 0.44 0.04)", +"oklab(10 110 10)", "oklab(10 110 10)", +"oklab(10% 110% 10%)", "oklab(0.1 0.44 0.04)", +"oklab(10 110 10 / 0)", "oklab(10 110 10 / 0)", +"oklab(10% 110% 10% / 0)", "oklab(0.1 0.44 0.04 / 0)", +"oklab(10 110 10 / 0.2)", "oklab(10 110 10 / 0.2)", +"oklab(10% 110% 10% / 0.2)", "oklab(0.1 0.44 0.04 / 0.2)", +"oklab(10 110 10 / 1)", "oklab(10 110 10)", +"oklab(10% 110% 10% / 1)", "oklab(0.1 0.44 0.04)", +"oklab(110 110 10)", "oklab(110 110 10)", +"oklab(110% 110% 10%)", "oklab(1.1 0.44 0.04)", +"oklab(110 110 10 / 0)", "oklab(110 110 10 / 0)", +"oklab(110% 110% 10% / 0)", "oklab(1.1 0.44 0.04 / 0)", +"oklab(110 110 10 / 0.2)", "oklab(110 110 10 / 0.2)", +"oklab(110% 110% 10% / 0.2)", "oklab(1.1 0.44 0.04 / 0.2)", +"oklab(110 110 10 / 1)", "oklab(110 110 10)", +"oklab(110% 110% 10% / 1)", "oklab(1.1 0.44 0.04)", +"oklab(-10 110 10)", "oklab(-10 110 10)", +"oklab(-10% 110% 10%)", "oklab(-0.1 0.44 0.04)", +"oklab(-10 110 10 / 0)", "oklab(-10 110 10 / 0)", +"oklab(-10% 110% 10% / 0)", "oklab(-0.1 0.44 0.04 / 0)", +"oklab(-10 110 10 / 0.2)", "oklab(-10 110 10 / 0.2)", +"oklab(-10% 110% 10% / 0.2)", "oklab(-0.1 0.44 0.04 / 0.2)", +"oklab(-10 110 10 / 1)", "oklab(-10 110 10)", +"oklab(-10% 110% 10% / 1)", "oklab(-0.1 0.44 0.04)", +"oklab(0 -10 10)", "oklab(0 -10 10)", +"oklab(0% -10% 10%)", "oklab(0 -0.04 0.04)", +"oklab(0 -10 10 / 0)", "oklab(0 -10 10 / 0)", +"oklab(0% -10% 10% / 0)", "oklab(0 -0.04 0.04 / 0)", +"oklab(0 -10 10 / 0.2)", "oklab(0 -10 10 / 0.2)", +"oklab(0% -10% 10% / 0.2)", "oklab(0 -0.04 0.04 / 0.2)", +"oklab(0 -10 10 / 1)", "oklab(0 -10 10)", +"oklab(0% -10% 10% / 1)", "oklab(0 -0.04 0.04)", +"oklab(10 -10 10)", "oklab(10 -10 10)", +"oklab(10% -10% 10%)", "oklab(0.1 -0.04 0.04)", +"oklab(10 -10 10 / 0)", "oklab(10 -10 10 / 0)", +"oklab(10% -10% 10% / 0)", "oklab(0.1 -0.04 0.04 / 0)", +"oklab(10 -10 10 / 0.2)", "oklab(10 -10 10 / 0.2)", +"oklab(10% -10% 10% / 0.2)", "oklab(0.1 -0.04 0.04 / 0.2)", +"oklab(10 -10 10 / 1)", "oklab(10 -10 10)", +"oklab(10% -10% 10% / 1)", "oklab(0.1 -0.04 0.04)", +"oklab(110 -10 10)", "oklab(110 -10 10)", +"oklab(110% -10% 10%)", "oklab(1.1 -0.04 0.04)", +"oklab(110 -10 10 / 0)", "oklab(110 -10 10 / 0)", +"oklab(110% -10% 10% / 0)", "oklab(1.1 -0.04 0.04 / 0)", +"oklab(110 -10 10 / 0.2)", "oklab(110 -10 10 / 0.2)", +"oklab(110% -10% 10% / 0.2)", "oklab(1.1 -0.04 0.04 / 0.2)", +"oklab(110 -10 10 / 1)", "oklab(110 -10 10)", +"oklab(110% -10% 10% / 1)", "oklab(1.1 -0.04 0.04)", +"oklab(-10 -10 10)", "oklab(-10 -10 10)", +"oklab(-10% -10% 10%)", "oklab(-0.1 -0.04 0.04)", +"oklab(-10 -10 10 / 0)", "oklab(-10 -10 10 / 0)", +"oklab(-10% -10% 10% / 0)", "oklab(-0.1 -0.04 0.04 / 0)", +"oklab(-10 -10 10 / 0.2)", "oklab(-10 -10 10 / 0.2)", +"oklab(-10% -10% 10% / 0.2)", "oklab(-0.1 -0.04 0.04 / 0.2)", +"oklab(-10 -10 10 / 1)", "oklab(-10 -10 10)", +"oklab(-10% -10% 10% / 1)", "oklab(-0.1 -0.04 0.04)", +"oklab(0 0 110)", "oklab(0 0 110)", +"oklab(0% 0% 110%)", "oklab(0 0 0.44)", +"oklab(0 0 110 / 0)", "oklab(0 0 110 / 0)", +"oklab(0% 0% 110% / 0)", "oklab(0 0 0.44 / 0)", +"oklab(0 0 110 / 0.2)", "oklab(0 0 110 / 0.2)", +"oklab(0% 0% 110% / 0.2)", "oklab(0 0 0.44 / 0.2)", +"oklab(0 0 110 / 1)", "oklab(0 0 110)", +"oklab(0% 0% 110% / 1)", "oklab(0 0 0.44)", +"oklab(10 0 110)", "oklab(10 0 110)", +"oklab(10% 0% 110%)", "oklab(0.1 0 0.44)", +"oklab(10 0 110 / 0)", "oklab(10 0 110 / 0)", +"oklab(10% 0% 110% / 0)", "oklab(0.1 0 0.44 / 0)", +"oklab(10 0 110 / 0.2)", "oklab(10 0 110 / 0.2)", +"oklab(10% 0% 110% / 0.2)", "oklab(0.1 0 0.44 / 0.2)", +"oklab(10 0 110 / 1)", "oklab(10 0 110)", +"oklab(10% 0% 110% / 1)", "oklab(0.1 0 0.44)", +"oklab(110 0 110)", "oklab(110 0 110)", +"oklab(110% 0% 110%)", "oklab(1.1 0 0.44)", +"oklab(110 0 110 / 0)", "oklab(110 0 110 / 0)", +"oklab(110% 0% 110% / 0)", "oklab(1.1 0 0.44 / 0)", +"oklab(110 0 110 / 0.2)", "oklab(110 0 110 / 0.2)", +"oklab(110% 0% 110% / 0.2)", "oklab(1.1 0 0.44 / 0.2)", +"oklab(110 0 110 / 1)", "oklab(110 0 110)", +"oklab(110% 0% 110% / 1)", "oklab(1.1 0 0.44)", +"oklab(-10 0 110)", "oklab(-10 0 110)", +"oklab(-10% 0% 110%)", "oklab(-0.1 0 0.44)", +"oklab(-10 0 110 / 0)", "oklab(-10 0 110 / 0)", +"oklab(-10% 0% 110% / 0)", "oklab(-0.1 0 0.44 / 0)", +"oklab(-10 0 110 / 0.2)", "oklab(-10 0 110 / 0.2)", +"oklab(-10% 0% 110% / 0.2)", "oklab(-0.1 0 0.44 / 0.2)", +"oklab(-10 0 110 / 1)", "oklab(-10 0 110)", +"oklab(-10% 0% 110% / 1)", "oklab(-0.1 0 0.44)", +"oklab(0 10 110)", "oklab(0 10 110)", +"oklab(0% 10% 110%)", "oklab(0 0.04 0.44)", +"oklab(0 10 110 / 0)", "oklab(0 10 110 / 0)", +"oklab(0% 10% 110% / 0)", "oklab(0 0.04 0.44 / 0)", +"oklab(0 10 110 / 0.2)", "oklab(0 10 110 / 0.2)", +"oklab(0% 10% 110% / 0.2)", "oklab(0 0.04 0.44 / 0.2)", +"oklab(0 10 110 / 1)", "oklab(0 10 110)", +"oklab(0% 10% 110% / 1)", "oklab(0 0.04 0.44)", +"oklab(10 10 110)", "oklab(10 10 110)", +"oklab(10% 10% 110%)", "oklab(0.1 0.04 0.44)", +"oklab(10 10 110 / 0)", "oklab(10 10 110 / 0)", +"oklab(10% 10% 110% / 0)", "oklab(0.1 0.04 0.44 / 0)", +"oklab(10 10 110 / 0.2)", "oklab(10 10 110 / 0.2)", +"oklab(10% 10% 110% / 0.2)", "oklab(0.1 0.04 0.44 / 0.2)", +"oklab(10 10 110 / 1)", "oklab(10 10 110)", +"oklab(10% 10% 110% / 1)", "oklab(0.1 0.04 0.44)", +"oklab(110 10 110)", "oklab(110 10 110)", +"oklab(110% 10% 110%)", "oklab(1.1 0.04 0.44)", +"oklab(110 10 110 / 0)", "oklab(110 10 110 / 0)", +"oklab(110% 10% 110% / 0)", "oklab(1.1 0.04 0.44 / 0)", +"oklab(110 10 110 / 0.2)", "oklab(110 10 110 / 0.2)", +"oklab(110% 10% 110% / 0.2)", "oklab(1.1 0.04 0.44 / 0.2)", +"oklab(110 10 110 / 1)", "oklab(110 10 110)", +"oklab(110% 10% 110% / 1)", "oklab(1.1 0.04 0.44)", +"oklab(-10 10 110)", "oklab(-10 10 110)", +"oklab(-10% 10% 110%)", "oklab(-0.1 0.04 0.44)", +"oklab(-10 10 110 / 0)", "oklab(-10 10 110 / 0)", +"oklab(-10% 10% 110% / 0)", "oklab(-0.1 0.04 0.44 / 0)", +"oklab(-10 10 110 / 0.2)", "oklab(-10 10 110 / 0.2)", +"oklab(-10% 10% 110% / 0.2)", "oklab(-0.1 0.04 0.44 / 0.2)", +"oklab(-10 10 110 / 1)", "oklab(-10 10 110)", +"oklab(-10% 10% 110% / 1)", "oklab(-0.1 0.04 0.44)", +"oklab(0 110 110)", "oklab(0 110 110)", +"oklab(0% 110% 110%)", "oklab(0 0.44 0.44)", +"oklab(0 110 110 / 0)", "oklab(0 110 110 / 0)", +"oklab(0% 110% 110% / 0)", "oklab(0 0.44 0.44 / 0)", +"oklab(0 110 110 / 0.2)", "oklab(0 110 110 / 0.2)", +"oklab(0% 110% 110% / 0.2)", "oklab(0 0.44 0.44 / 0.2)", +"oklab(0 110 110 / 1)", "oklab(0 110 110)", +"oklab(0% 110% 110% / 1)", "oklab(0 0.44 0.44)", +"oklab(10 110 110)", "oklab(10 110 110)", +"oklab(10% 110% 110%)", "oklab(0.1 0.44 0.44)", +"oklab(10 110 110 / 0)", "oklab(10 110 110 / 0)", +"oklab(10% 110% 110% / 0)", "oklab(0.1 0.44 0.44 / 0)", +"oklab(10 110 110 / 0.2)", "oklab(10 110 110 / 0.2)", +"oklab(10% 110% 110% / 0.2)", "oklab(0.1 0.44 0.44 / 0.2)", +"oklab(10 110 110 / 1)", "oklab(10 110 110)", +"oklab(10% 110% 110% / 1)", "oklab(0.1 0.44 0.44)", +"oklab(110 110 110)", "oklab(110 110 110)", +"oklab(110% 110% 110%)", "oklab(1.1 0.44 0.44)", +"oklab(110 110 110 / 0)", "oklab(110 110 110 / 0)", +"oklab(110% 110% 110% / 0)", "oklab(1.1 0.44 0.44 / 0)", +"oklab(110 110 110 / 0.2)", "oklab(110 110 110 / 0.2)", +"oklab(110% 110% 110% / 0.2)", "oklab(1.1 0.44 0.44 / 0.2)", +"oklab(110 110 110 / 1)", "oklab(110 110 110)", +"oklab(110% 110% 110% / 1)", "oklab(1.1 0.44 0.44)", +"oklab(-10 110 110)", "oklab(-10 110 110)", +"oklab(-10% 110% 110%)", "oklab(-0.1 0.44 0.44)", +"oklab(-10 110 110 / 0)", "oklab(-10 110 110 / 0)", +"oklab(-10% 110% 110% / 0)", "oklab(-0.1 0.44 0.44 / 0)", +"oklab(-10 110 110 / 0.2)", "oklab(-10 110 110 / 0.2)", +"oklab(-10% 110% 110% / 0.2)", "oklab(-0.1 0.44 0.44 / 0.2)", +"oklab(-10 110 110 / 1)", "oklab(-10 110 110)", +"oklab(-10% 110% 110% / 1)", "oklab(-0.1 0.44 0.44)", +"oklab(0 -10 110)", "oklab(0 -10 110)", +"oklab(0% -10% 110%)", "oklab(0 -0.04 0.44)", +"oklab(0 -10 110 / 0)", "oklab(0 -10 110 / 0)", +"oklab(0% -10% 110% / 0)", "oklab(0 -0.04 0.44 / 0)", +"oklab(0 -10 110 / 0.2)", "oklab(0 -10 110 / 0.2)", +"oklab(0% -10% 110% / 0.2)", "oklab(0 -0.04 0.44 / 0.2)", +"oklab(0 -10 110 / 1)", "oklab(0 -10 110)", +"oklab(0% -10% 110% / 1)", "oklab(0 -0.04 0.44)", +"oklab(10 -10 110)", "oklab(10 -10 110)", +"oklab(10% -10% 110%)", "oklab(0.1 -0.04 0.44)", +"oklab(10 -10 110 / 0)", "oklab(10 -10 110 / 0)", +"oklab(10% -10% 110% / 0)", "oklab(0.1 -0.04 0.44 / 0)", +"oklab(10 -10 110 / 0.2)", "oklab(10 -10 110 / 0.2)", +"oklab(10% -10% 110% / 0.2)", "oklab(0.1 -0.04 0.44 / 0.2)", +"oklab(10 -10 110 / 1)", "oklab(10 -10 110)", +"oklab(10% -10% 110% / 1)", "oklab(0.1 -0.04 0.44)", +"oklab(110 -10 110)", "oklab(110 -10 110)", +"oklab(110% -10% 110%)", "oklab(1.1 -0.04 0.44)", +"oklab(110 -10 110 / 0)", "oklab(110 -10 110 / 0)", +"oklab(110% -10% 110% / 0)", "oklab(1.1 -0.04 0.44 / 0)", +"oklab(110 -10 110 / 0.2)", "oklab(110 -10 110 / 0.2)", +"oklab(110% -10% 110% / 0.2)", "oklab(1.1 -0.04 0.44 / 0.2)", +"oklab(110 -10 110 / 1)", "oklab(110 -10 110)", +"oklab(110% -10% 110% / 1)", "oklab(1.1 -0.04 0.44)", +"oklab(-10 -10 110)", "oklab(-10 -10 110)", +"oklab(-10% -10% 110%)", "oklab(-0.1 -0.04 0.44)", +"oklab(-10 -10 110 / 0)", "oklab(-10 -10 110 / 0)", +"oklab(-10% -10% 110% / 0)", "oklab(-0.1 -0.04 0.44 / 0)", +"oklab(-10 -10 110 / 0.2)", "oklab(-10 -10 110 / 0.2)", +"oklab(-10% -10% 110% / 0.2)", "oklab(-0.1 -0.04 0.44 / 0.2)", +"oklab(-10 -10 110 / 1)", "oklab(-10 -10 110)", +"oklab(-10% -10% 110% / 1)", "oklab(-0.1 -0.04 0.44)", +"oklab(0 0 -10)", "oklab(0 0 -10)", +"oklab(0% 0% -10%)", "oklab(0 0 -0.04)", +"oklab(0 0 -10 / 0)", "oklab(0 0 -10 / 0)", +"oklab(0% 0% -10% / 0)", "oklab(0 0 -0.04 / 0)", +"oklab(0 0 -10 / 0.2)", "oklab(0 0 -10 / 0.2)", +"oklab(0% 0% -10% / 0.2)", "oklab(0 0 -0.04 / 0.2)", +"oklab(0 0 -10 / 1)", "oklab(0 0 -10)", +"oklab(0% 0% -10% / 1)", "oklab(0 0 -0.04)", +"oklab(10 0 -10)", "oklab(10 0 -10)", +"oklab(10% 0% -10%)", "oklab(0.1 0 -0.04)", +"oklab(10 0 -10 / 0)", "oklab(10 0 -10 / 0)", +"oklab(10% 0% -10% / 0)", "oklab(0.1 0 -0.04 / 0)", +"oklab(10 0 -10 / 0.2)", "oklab(10 0 -10 / 0.2)", +"oklab(10% 0% -10% / 0.2)", "oklab(0.1 0 -0.04 / 0.2)", +"oklab(10 0 -10 / 1)", "oklab(10 0 -10)", +"oklab(10% 0% -10% / 1)", "oklab(0.1 0 -0.04)", +"oklab(110 0 -10)", "oklab(110 0 -10)", +"oklab(110% 0% -10%)", "oklab(1.1 0 -0.04)", +"oklab(110 0 -10 / 0)", "oklab(110 0 -10 / 0)", +"oklab(110% 0% -10% / 0)", "oklab(1.1 0 -0.04 / 0)", +"oklab(110 0 -10 / 0.2)", "oklab(110 0 -10 / 0.2)", +"oklab(110% 0% -10% / 0.2)", "oklab(1.1 0 -0.04 / 0.2)", +"oklab(110 0 -10 / 1)", "oklab(110 0 -10)", +"oklab(110% 0% -10% / 1)", "oklab(1.1 0 -0.04)", +"oklab(-10 0 -10)", "oklab(-10 0 -10)", +"oklab(-10% 0% -10%)", "oklab(-0.1 0 -0.04)", +"oklab(-10 0 -10 / 0)", "oklab(-10 0 -10 / 0)", +"oklab(-10% 0% -10% / 0)", "oklab(-0.1 0 -0.04 / 0)", +"oklab(-10 0 -10 / 0.2)", "oklab(-10 0 -10 / 0.2)", +"oklab(-10% 0% -10% / 0.2)", "oklab(-0.1 0 -0.04 / 0.2)", +"oklab(-10 0 -10 / 1)", "oklab(-10 0 -10)", +"oklab(-10% 0% -10% / 1)", "oklab(-0.1 0 -0.04)", +"oklab(0 10 -10)", "oklab(0 10 -10)", +"oklab(0% 10% -10%)", "oklab(0 0.04 -0.04)", +"oklab(0 10 -10 / 0)", "oklab(0 10 -10 / 0)", +"oklab(0% 10% -10% / 0)", "oklab(0 0.04 -0.04 / 0)", +"oklab(0 10 -10 / 0.2)", "oklab(0 10 -10 / 0.2)", +"oklab(0% 10% -10% / 0.2)", "oklab(0 0.04 -0.04 / 0.2)", +"oklab(0 10 -10 / 1)", "oklab(0 10 -10)", +"oklab(0% 10% -10% / 1)", "oklab(0 0.04 -0.04)", +"oklab(10 10 -10)", "oklab(10 10 -10)", +"oklab(10% 10% -10%)", "oklab(0.1 0.04 -0.04)", +"oklab(10 10 -10 / 0)", "oklab(10 10 -10 / 0)", +"oklab(10% 10% -10% / 0)", "oklab(0.1 0.04 -0.04 / 0)", +"oklab(10 10 -10 / 0.2)", "oklab(10 10 -10 / 0.2)", +"oklab(10% 10% -10% / 0.2)", "oklab(0.1 0.04 -0.04 / 0.2)", +"oklab(10 10 -10 / 1)", "oklab(10 10 -10)", +"oklab(10% 10% -10% / 1)", "oklab(0.1 0.04 -0.04)", +"oklab(110 10 -10)", "oklab(110 10 -10)", +"oklab(110% 10% -10%)", "oklab(1.1 0.04 -0.04)", +"oklab(110 10 -10 / 0)", "oklab(110 10 -10 / 0)", +"oklab(110% 10% -10% / 0)", "oklab(1.1 0.04 -0.04 / 0)", +"oklab(110 10 -10 / 0.2)", "oklab(110 10 -10 / 0.2)", +"oklab(110% 10% -10% / 0.2)", "oklab(1.1 0.04 -0.04 / 0.2)", +"oklab(110 10 -10 / 1)", "oklab(110 10 -10)", +"oklab(110% 10% -10% / 1)", "oklab(1.1 0.04 -0.04)", +"oklab(-10 10 -10)", "oklab(-10 10 -10)", +"oklab(-10% 10% -10%)", "oklab(-0.1 0.04 -0.04)", +"oklab(-10 10 -10 / 0)", "oklab(-10 10 -10 / 0)", +"oklab(-10% 10% -10% / 0)", "oklab(-0.1 0.04 -0.04 / 0)", +"oklab(-10 10 -10 / 0.2)", "oklab(-10 10 -10 / 0.2)", +"oklab(-10% 10% -10% / 0.2)", "oklab(-0.1 0.04 -0.04 / 0.2)", +"oklab(-10 10 -10 / 1)", "oklab(-10 10 -10)", +"oklab(-10% 10% -10% / 1)", "oklab(-0.1 0.04 -0.04)", +"oklab(0 110 -10)", "oklab(0 110 -10)", +"oklab(0% 110% -10%)", "oklab(0 0.44 -0.04)", +"oklab(0 110 -10 / 0)", "oklab(0 110 -10 / 0)", +"oklab(0% 110% -10% / 0)", "oklab(0 0.44 -0.04 / 0)", +"oklab(0 110 -10 / 0.2)", "oklab(0 110 -10 / 0.2)", +"oklab(0% 110% -10% / 0.2)", "oklab(0 0.44 -0.04 / 0.2)", +"oklab(0 110 -10 / 1)", "oklab(0 110 -10)", +"oklab(0% 110% -10% / 1)", "oklab(0 0.44 -0.04)", +"oklab(10 110 -10)", "oklab(10 110 -10)", +"oklab(10% 110% -10%)", "oklab(0.1 0.44 -0.04)", +"oklab(10 110 -10 / 0)", "oklab(10 110 -10 / 0)", +"oklab(10% 110% -10% / 0)", "oklab(0.1 0.44 -0.04 / 0)", +"oklab(10 110 -10 / 0.2)", "oklab(10 110 -10 / 0.2)", +"oklab(10% 110% -10% / 0.2)", "oklab(0.1 0.44 -0.04 / 0.2)", +"oklab(10 110 -10 / 1)", "oklab(10 110 -10)", +"oklab(10% 110% -10% / 1)", "oklab(0.1 0.44 -0.04)", +"oklab(110 110 -10)", "oklab(110 110 -10)", +"oklab(110% 110% -10%)", "oklab(1.1 0.44 -0.04)", +"oklab(110 110 -10 / 0)", "oklab(110 110 -10 / 0)", +"oklab(110% 110% -10% / 0)", "oklab(1.1 0.44 -0.04 / 0)", +"oklab(110 110 -10 / 0.2)", "oklab(110 110 -10 / 0.2)", +"oklab(110% 110% -10% / 0.2)", "oklab(1.1 0.44 -0.04 / 0.2)", +"oklab(110 110 -10 / 1)", "oklab(110 110 -10)", +"oklab(110% 110% -10% / 1)", "oklab(1.1 0.44 -0.04)", +"oklab(-10 110 -10)", "oklab(-10 110 -10)", +"oklab(-10% 110% -10%)", "oklab(-0.1 0.44 -0.04)", +"oklab(-10 110 -10 / 0)", "oklab(-10 110 -10 / 0)", +"oklab(-10% 110% -10% / 0)", "oklab(-0.1 0.44 -0.04 / 0)", +"oklab(-10 110 -10 / 0.2)", "oklab(-10 110 -10 / 0.2)", +"oklab(-10% 110% -10% / 0.2)", "oklab(-0.1 0.44 -0.04 / 0.2)", +"oklab(-10 110 -10 / 1)", "oklab(-10 110 -10)", +"oklab(-10% 110% -10% / 1)", "oklab(-0.1 0.44 -0.04)", +"oklab(0 -10 -10)", "oklab(0 -10 -10)", +"oklab(0% -10% -10%)", "oklab(0 -0.04 -0.04)", +"oklab(0 -10 -10 / 0)", "oklab(0 -10 -10 / 0)", +"oklab(0% -10% -10% / 0)", "oklab(0 -0.04 -0.04 / 0)", +"oklab(0 -10 -10 / 0.2)", "oklab(0 -10 -10 / 0.2)", +"oklab(0% -10% -10% / 0.2)", "oklab(0 -0.04 -0.04 / 0.2)", +"oklab(0 -10 -10 / 1)", "oklab(0 -10 -10)", +"oklab(0% -10% -10% / 1)", "oklab(0 -0.04 -0.04)", +"oklab(10 -10 -10)", "oklab(10 -10 -10)", +"oklab(10% -10% -10%)", "oklab(0.1 -0.04 -0.04)", +"oklab(10 -10 -10 / 0)", "oklab(10 -10 -10 / 0)", +"oklab(10% -10% -10% / 0)", "oklab(0.1 -0.04 -0.04 / 0)", +"oklab(10 -10 -10 / 0.2)", "oklab(10 -10 -10 / 0.2)", +"oklab(10% -10% -10% / 0.2)", "oklab(0.1 -0.04 -0.04 / 0.2)", +"oklab(10 -10 -10 / 1)", "oklab(10 -10 -10)", +"oklab(10% -10% -10% / 1)", "oklab(0.1 -0.04 -0.04)", +"oklab(110 -10 -10)", "oklab(110 -10 -10)", +"oklab(110% -10% -10%)", "oklab(1.1 -0.04 -0.04)", +"oklab(110 -10 -10 / 0)", "oklab(110 -10 -10 / 0)", +"oklab(110% -10% -10% / 0)", "oklab(1.1 -0.04 -0.04 / 0)", +"oklab(110 -10 -10 / 0.2)", "oklab(110 -10 -10 / 0.2)", +"oklab(110% -10% -10% / 0.2)", "oklab(1.1 -0.04 -0.04 / 0.2)", +"oklab(110 -10 -10 / 1)", "oklab(110 -10 -10)", +"oklab(110% -10% -10% / 1)", "oklab(1.1 -0.04 -0.04)", +"oklab(-10 -10 -10)", "oklab(-10 -10 -10)", +"oklab(-10% -10% -10%)", "oklab(-0.1 -0.04 -0.04)", +"oklab(-10 -10 -10 / 0)", "oklab(-10 -10 -10 / 0)", +"oklab(-10% -10% -10% / 0)", "oklab(-0.1 -0.04 -0.04 / 0)", +"oklab(-10 -10 -10 / 0.2)", "oklab(-10 -10 -10 / 0.2)", +"oklab(-10% -10% -10% / 0.2)", "oklab(-0.1 -0.04 -0.04 / 0.2)", +"oklab(-10 -10 -10 / 1)", "oklab(-10 -10 -10)", +"oklab(-10% -10% -10% / 1)", "oklab(-0.1 -0.04 -0.04)", +"lch(0 0 0)", "lch(0 0 0)", +"lch(0% 0% 0deg)", "lch(0 0 0)", +"lch(0 0 0 / 0)", "lch(0 0 0 / 0)", +"lch(0% 0% 0deg / 0)", "lch(0 0 0 / 0)", +"lch(0 0 0 / 0.2)", "lch(0 0 0 / 0.2)", +"lch(0% 0% 0deg / 0.2)", "lch(0 0 0 / 0.2)", +"lch(0 0 0 / 1)", "lch(0 0 0)", +"lch(0% 0% 0deg / 1)", "lch(0 0 0)", +"lch(10 0 0)", "lch(10 0 0)", +"lch(10% 0% 0deg)", "lch(10 0 0)", +"lch(10 0 0 / 0)", "lch(10 0 0 / 0)", +"lch(10% 0% 0deg / 0)", "lch(10 0 0 / 0)", +"lch(10 0 0 / 0.2)", "lch(10 0 0 / 0.2)", +"lch(10% 0% 0deg / 0.2)", "lch(10 0 0 / 0.2)", +"lch(10 0 0 / 1)", "lch(10 0 0)", +"lch(10% 0% 0deg / 1)", "lch(10 0 0)", +"lch(110 0 0)", "lch(110 0 0)", +"lch(110% 0% 0deg)", "lch(110 0 0)", +"lch(110 0 0 / 0)", "lch(110 0 0 / 0)", +"lch(110% 0% 0deg / 0)", "lch(110 0 0 / 0)", +"lch(110 0 0 / 0.2)", "lch(110 0 0 / 0.2)", +"lch(110% 0% 0deg / 0.2)", "lch(110 0 0 / 0.2)", +"lch(110 0 0 / 1)", "lch(110 0 0)", +"lch(110% 0% 0deg / 1)", "lch(110 0 0)", +"lch(-10 0 0)", "lch(-10 0 0)", +"lch(-10% 0% 0deg)", "lch(-10 0 0)", +"lch(-10 0 0 / 0)", "lch(-10 0 0 / 0)", +"lch(-10% 0% 0deg / 0)", "lch(-10 0 0 / 0)", +"lch(-10 0 0 / 0.2)", "lch(-10 0 0 / 0.2)", +"lch(-10% 0% 0deg / 0.2)", "lch(-10 0 0 / 0.2)", +"lch(-10 0 0 / 1)", "lch(-10 0 0)", +"lch(-10% 0% 0deg / 1)", "lch(-10 0 0)", +"lch(0 10 0)", "lch(0 10 0)", +"lch(0% 10% 0deg)", "lch(0 15 0)", +"lch(0 10 0 / 0)", "lch(0 10 0 / 0)", +"lch(0% 10% 0deg / 0)", "lch(0 15 0 / 0)", +"lch(0 10 0 / 0.2)", "lch(0 10 0 / 0.2)", +"lch(0% 10% 0deg / 0.2)", "lch(0 15 0 / 0.2)", +"lch(0 10 0 / 1)", "lch(0 10 0)", +"lch(0% 10% 0deg / 1)", "lch(0 15 0)", +"lch(10 10 0)", "lch(10 10 0)", +"lch(10% 10% 0deg)", "lch(10 15 0)", +"lch(10 10 0 / 0)", "lch(10 10 0 / 0)", +"lch(10% 10% 0deg / 0)", "lch(10 15 0 / 0)", +"lch(10 10 0 / 0.2)", "lch(10 10 0 / 0.2)", +"lch(10% 10% 0deg / 0.2)", "lch(10 15 0 / 0.2)", +"lch(10 10 0 / 1)", "lch(10 10 0)", +"lch(10% 10% 0deg / 1)", "lch(10 15 0)", +"lch(110 10 0)", "lch(110 10 0)", +"lch(110% 10% 0deg)", "lch(110 15 0)", +"lch(110 10 0 / 0)", "lch(110 10 0 / 0)", +"lch(110% 10% 0deg / 0)", "lch(110 15 0 / 0)", +"lch(110 10 0 / 0.2)", "lch(110 10 0 / 0.2)", +"lch(110% 10% 0deg / 0.2)", "lch(110 15 0 / 0.2)", +"lch(110 10 0 / 1)", "lch(110 10 0)", +"lch(110% 10% 0deg / 1)", "lch(110 15 0)", +"lch(-10 10 0)", "lch(-10 10 0)", +"lch(-10% 10% 0deg)", "lch(-10 15 0)", +"lch(-10 10 0 / 0)", "lch(-10 10 0 / 0)", +"lch(-10% 10% 0deg / 0)", "lch(-10 15 0 / 0)", +"lch(-10 10 0 / 0.2)", "lch(-10 10 0 / 0.2)", +"lch(-10% 10% 0deg / 0.2)", "lch(-10 15 0 / 0.2)", +"lch(-10 10 0 / 1)", "lch(-10 10 0)", +"lch(-10% 10% 0deg / 1)", "lch(-10 15 0)", +"lch(0 110 0)", "lch(0 110 0)", +"lch(0% 110% 0deg)", "lch(0 165 0)", +"lch(0 110 0 / 0)", "lch(0 110 0 / 0)", +"lch(0% 110% 0deg / 0)", "lch(0 165 0 / 0)", +"lch(0 110 0 / 0.2)", "lch(0 110 0 / 0.2)", +"lch(0% 110% 0deg / 0.2)", "lch(0 165 0 / 0.2)", +"lch(0 110 0 / 1)", "lch(0 110 0)", +"lch(0% 110% 0deg / 1)", "lch(0 165 0)", +"lch(10 110 0)", "lch(10 110 0)", +"lch(10% 110% 0deg)", "lch(10 165 0)", +"lch(10 110 0 / 0)", "lch(10 110 0 / 0)", +"lch(10% 110% 0deg / 0)", "lch(10 165 0 / 0)", +"lch(10 110 0 / 0.2)", "lch(10 110 0 / 0.2)", +"lch(10% 110% 0deg / 0.2)", "lch(10 165 0 / 0.2)", +"lch(10 110 0 / 1)", "lch(10 110 0)", +"lch(10% 110% 0deg / 1)", "lch(10 165 0)", +"lch(110 110 0)", "lch(110 110 0)", +"lch(110% 110% 0deg)", "lch(110 165 0)", +"lch(110 110 0 / 0)", "lch(110 110 0 / 0)", +"lch(110% 110% 0deg / 0)", "lch(110 165 0 / 0)", +"lch(110 110 0 / 0.2)", "lch(110 110 0 / 0.2)", +"lch(110% 110% 0deg / 0.2)", "lch(110 165 0 / 0.2)", +"lch(110 110 0 / 1)", "lch(110 110 0)", +"lch(110% 110% 0deg / 1)", "lch(110 165 0)", +"lch(-10 110 0)", "lch(-10 110 0)", +"lch(-10% 110% 0deg)", "lch(-10 165 0)", +"lch(-10 110 0 / 0)", "lch(-10 110 0 / 0)", +"lch(-10% 110% 0deg / 0)", "lch(-10 165 0 / 0)", +"lch(-10 110 0 / 0.2)", "lch(-10 110 0 / 0.2)", +"lch(-10% 110% 0deg / 0.2)", "lch(-10 165 0 / 0.2)", +"lch(-10 110 0 / 1)", "lch(-10 110 0)", +"lch(-10% 110% 0deg / 1)", "lch(-10 165 0)", +"lch(0 -10 0)", "lch(0 -10 0)", +"lch(0% -10% 0deg)", "lch(0 -15 0)", +"lch(0 -10 0 / 0)", "lch(0 -10 0 / 0)", +"lch(0% -10% 0deg / 0)", "lch(0 -15 0 / 0)", +"lch(0 -10 0 / 0.2)", "lch(0 -10 0 / 0.2)", +"lch(0% -10% 0deg / 0.2)", "lch(0 -15 0 / 0.2)", +"lch(0 -10 0 / 1)", "lch(0 -10 0)", +"lch(0% -10% 0deg / 1)", "lch(0 -15 0)", +"lch(10 -10 0)", "lch(10 -10 0)", +"lch(10% -10% 0deg)", "lch(10 -15 0)", +"lch(10 -10 0 / 0)", "lch(10 -10 0 / 0)", +"lch(10% -10% 0deg / 0)", "lch(10 -15 0 / 0)", +"lch(10 -10 0 / 0.2)", "lch(10 -10 0 / 0.2)", +"lch(10% -10% 0deg / 0.2)", "lch(10 -15 0 / 0.2)", +"lch(10 -10 0 / 1)", "lch(10 -10 0)", +"lch(10% -10% 0deg / 1)", "lch(10 -15 0)", +"lch(110 -10 0)", "lch(110 -10 0)", +"lch(110% -10% 0deg)", "lch(110 -15 0)", +"lch(110 -10 0 / 0)", "lch(110 -10 0 / 0)", +"lch(110% -10% 0deg / 0)", "lch(110 -15 0 / 0)", +"lch(110 -10 0 / 0.2)", "lch(110 -10 0 / 0.2)", +"lch(110% -10% 0deg / 0.2)", "lch(110 -15 0 / 0.2)", +"lch(110 -10 0 / 1)", "lch(110 -10 0)", +"lch(110% -10% 0deg / 1)", "lch(110 -15 0)", +"lch(-10 -10 0)", "lch(-10 -10 0)", +"lch(-10% -10% 0deg)", "lch(-10 -15 0)", +"lch(-10 -10 0 / 0)", "lch(-10 -10 0 / 0)", +"lch(-10% -10% 0deg / 0)", "lch(-10 -15 0 / 0)", +"lch(-10 -10 0 / 0.2)", "lch(-10 -10 0 / 0.2)", +"lch(-10% -10% 0deg / 0.2)", "lch(-10 -15 0 / 0.2)", +"lch(-10 -10 0 / 1)", "lch(-10 -10 0)", +"lch(-10% -10% 0deg / 1)", "lch(-10 -15 0)", +"lch(0 0 30)", "lch(0 0 30)", +"lch(0% 0% 30deg)", "lch(0 0 30)", +"lch(0 0 30 / 0)", "lch(0 0 30 / 0)", +"lch(0% 0% 30deg / 0)", "lch(0 0 30 / 0)", +"lch(0 0 30 / 0.2)", "lch(0 0 30 / 0.2)", +"lch(0% 0% 30deg / 0.2)", "lch(0 0 30 / 0.2)", +"lch(0 0 30 / 1)", "lch(0 0 30)", +"lch(0% 0% 30deg / 1)", "lch(0 0 30)", +"lch(10 0 30)", "lch(10 0 30)", +"lch(10% 0% 30deg)", "lch(10 0 30)", +"lch(10 0 30 / 0)", "lch(10 0 30 / 0)", +"lch(10% 0% 30deg / 0)", "lch(10 0 30 / 0)", +"lch(10 0 30 / 0.2)", "lch(10 0 30 / 0.2)", +"lch(10% 0% 30deg / 0.2)", "lch(10 0 30 / 0.2)", +"lch(10 0 30 / 1)", "lch(10 0 30)", +"lch(10% 0% 30deg / 1)", "lch(10 0 30)", +"lch(110 0 30)", "lch(110 0 30)", +"lch(110% 0% 30deg)", "lch(110 0 30)", +"lch(110 0 30 / 0)", "lch(110 0 30 / 0)", +"lch(110% 0% 30deg / 0)", "lch(110 0 30 / 0)", +"lch(110 0 30 / 0.2)", "lch(110 0 30 / 0.2)", +"lch(110% 0% 30deg / 0.2)", "lch(110 0 30 / 0.2)", +"lch(110 0 30 / 1)", "lch(110 0 30)", +"lch(110% 0% 30deg / 1)", "lch(110 0 30)", +"lch(-10 0 30)", "lch(-10 0 30)", +"lch(-10% 0% 30deg)", "lch(-10 0 30)", +"lch(-10 0 30 / 0)", "lch(-10 0 30 / 0)", +"lch(-10% 0% 30deg / 0)", "lch(-10 0 30 / 0)", +"lch(-10 0 30 / 0.2)", "lch(-10 0 30 / 0.2)", +"lch(-10% 0% 30deg / 0.2)", "lch(-10 0 30 / 0.2)", +"lch(-10 0 30 / 1)", "lch(-10 0 30)", +"lch(-10% 0% 30deg / 1)", "lch(-10 0 30)", +"lch(0 10 30)", "lch(0 10 30)", +"lch(0% 10% 30deg)", "lch(0 15 30)", +"lch(0 10 30 / 0)", "lch(0 10 30 / 0)", +"lch(0% 10% 30deg / 0)", "lch(0 15 30 / 0)", +"lch(0 10 30 / 0.2)", "lch(0 10 30 / 0.2)", +"lch(0% 10% 30deg / 0.2)", "lch(0 15 30 / 0.2)", +"lch(0 10 30 / 1)", "lch(0 10 30)", +"lch(0% 10% 30deg / 1)", "lch(0 15 30)", +"lch(10 10 30)", "lch(10 10 30)", +"lch(10% 10% 30deg)", "lch(10 15 30)", +"lch(10 10 30 / 0)", "lch(10 10 30 / 0)", +"lch(10% 10% 30deg / 0)", "lch(10 15 30 / 0)", +"lch(10 10 30 / 0.2)", "lch(10 10 30 / 0.2)", +"lch(10% 10% 30deg / 0.2)", "lch(10 15 30 / 0.2)", +"lch(10 10 30 / 1)", "lch(10 10 30)", +"lch(10% 10% 30deg / 1)", "lch(10 15 30)", +"lch(110 10 30)", "lch(110 10 30)", +"lch(110% 10% 30deg)", "lch(110 15 30)", +"lch(110 10 30 / 0)", "lch(110 10 30 / 0)", +"lch(110% 10% 30deg / 0)", "lch(110 15 30 / 0)", +"lch(110 10 30 / 0.2)", "lch(110 10 30 / 0.2)", +"lch(110% 10% 30deg / 0.2)", "lch(110 15 30 / 0.2)", +"lch(110 10 30 / 1)", "lch(110 10 30)", +"lch(110% 10% 30deg / 1)", "lch(110 15 30)", +"lch(-10 10 30)", "lch(-10 10 30)", +"lch(-10% 10% 30deg)", "lch(-10 15 30)", +"lch(-10 10 30 / 0)", "lch(-10 10 30 / 0)", +"lch(-10% 10% 30deg / 0)", "lch(-10 15 30 / 0)", +"lch(-10 10 30 / 0.2)", "lch(-10 10 30 / 0.2)", +"lch(-10% 10% 30deg / 0.2)", "lch(-10 15 30 / 0.2)", +"lch(-10 10 30 / 1)", "lch(-10 10 30)", +"lch(-10% 10% 30deg / 1)", "lch(-10 15 30)", +"lch(0 110 30)", "lch(0 110 30)", +"lch(0% 110% 30deg)", "lch(0 165 30)", +"lch(0 110 30 / 0)", "lch(0 110 30 / 0)", +"lch(0% 110% 30deg / 0)", "lch(0 165 30 / 0)", +"lch(0 110 30 / 0.2)", "lch(0 110 30 / 0.2)", +"lch(0% 110% 30deg / 0.2)", "lch(0 165 30 / 0.2)", +"lch(0 110 30 / 1)", "lch(0 110 30)", +"lch(0% 110% 30deg / 1)", "lch(0 165 30)", +"lch(10 110 30)", "lch(10 110 30)", +"lch(10% 110% 30deg)", "lch(10 165 30)", +"lch(10 110 30 / 0)", "lch(10 110 30 / 0)", +"lch(10% 110% 30deg / 0)", "lch(10 165 30 / 0)", +"lch(10 110 30 / 0.2)", "lch(10 110 30 / 0.2)", +"lch(10% 110% 30deg / 0.2)", "lch(10 165 30 / 0.2)", +"lch(10 110 30 / 1)", "lch(10 110 30)", +"lch(10% 110% 30deg / 1)", "lch(10 165 30)", +"lch(110 110 30)", "lch(110 110 30)", +"lch(110% 110% 30deg)", "lch(110 165 30)", +"lch(110 110 30 / 0)", "lch(110 110 30 / 0)", +"lch(110% 110% 30deg / 0)", "lch(110 165 30 / 0)", +"lch(110 110 30 / 0.2)", "lch(110 110 30 / 0.2)", +"lch(110% 110% 30deg / 0.2)", "lch(110 165 30 / 0.2)", +"lch(110 110 30 / 1)", "lch(110 110 30)", +"lch(110% 110% 30deg / 1)", "lch(110 165 30)", +"lch(-10 110 30)", "lch(-10 110 30)", +"lch(-10% 110% 30deg)", "lch(-10 165 30)", +"lch(-10 110 30 / 0)", "lch(-10 110 30 / 0)", +"lch(-10% 110% 30deg / 0)", "lch(-10 165 30 / 0)", +"lch(-10 110 30 / 0.2)", "lch(-10 110 30 / 0.2)", +"lch(-10% 110% 30deg / 0.2)", "lch(-10 165 30 / 0.2)", +"lch(-10 110 30 / 1)", "lch(-10 110 30)", +"lch(-10% 110% 30deg / 1)", "lch(-10 165 30)", +"lch(0 -10 30)", "lch(0 -10 30)", +"lch(0% -10% 30deg)", "lch(0 -15 30)", +"lch(0 -10 30 / 0)", "lch(0 -10 30 / 0)", +"lch(0% -10% 30deg / 0)", "lch(0 -15 30 / 0)", +"lch(0 -10 30 / 0.2)", "lch(0 -10 30 / 0.2)", +"lch(0% -10% 30deg / 0.2)", "lch(0 -15 30 / 0.2)", +"lch(0 -10 30 / 1)", "lch(0 -10 30)", +"lch(0% -10% 30deg / 1)", "lch(0 -15 30)", +"lch(10 -10 30)", "lch(10 -10 30)", +"lch(10% -10% 30deg)", "lch(10 -15 30)", +"lch(10 -10 30 / 0)", "lch(10 -10 30 / 0)", +"lch(10% -10% 30deg / 0)", "lch(10 -15 30 / 0)", +"lch(10 -10 30 / 0.2)", "lch(10 -10 30 / 0.2)", +"lch(10% -10% 30deg / 0.2)", "lch(10 -15 30 / 0.2)", +"lch(10 -10 30 / 1)", "lch(10 -10 30)", +"lch(10% -10% 30deg / 1)", "lch(10 -15 30)", +"lch(110 -10 30)", "lch(110 -10 30)", +"lch(110% -10% 30deg)", "lch(110 -15 30)", +"lch(110 -10 30 / 0)", "lch(110 -10 30 / 0)", +"lch(110% -10% 30deg / 0)", "lch(110 -15 30 / 0)", +"lch(110 -10 30 / 0.2)", "lch(110 -10 30 / 0.2)", +"lch(110% -10% 30deg / 0.2)", "lch(110 -15 30 / 0.2)", +"lch(110 -10 30 / 1)", "lch(110 -10 30)", +"lch(110% -10% 30deg / 1)", "lch(110 -15 30)", +"lch(-10 -10 30)", "lch(-10 -10 30)", +"lch(-10% -10% 30deg)", "lch(-10 -15 30)", +"lch(-10 -10 30 / 0)", "lch(-10 -10 30 / 0)", +"lch(-10% -10% 30deg / 0)", "lch(-10 -15 30 / 0)", +"lch(-10 -10 30 / 0.2)", "lch(-10 -10 30 / 0.2)", +"lch(-10% -10% 30deg / 0.2)", "lch(-10 -15 30 / 0.2)", +"lch(-10 -10 30 / 1)", "lch(-10 -10 30)", +"lch(-10% -10% 30deg / 1)", "lch(-10 -15 30)", +"lch(0 0 60)", "lch(0 0 60)", +"lch(0% 0% 60deg)", "lch(0 0 60)", +"lch(0 0 60 / 0)", "lch(0 0 60 / 0)", +"lch(0% 0% 60deg / 0)", "lch(0 0 60 / 0)", +"lch(0 0 60 / 0.2)", "lch(0 0 60 / 0.2)", +"lch(0% 0% 60deg / 0.2)", "lch(0 0 60 / 0.2)", +"lch(0 0 60 / 1)", "lch(0 0 60)", +"lch(0% 0% 60deg / 1)", "lch(0 0 60)", +"lch(10 0 60)", "lch(10 0 60)", +"lch(10% 0% 60deg)", "lch(10 0 60)", +"lch(10 0 60 / 0)", "lch(10 0 60 / 0)", +"lch(10% 0% 60deg / 0)", "lch(10 0 60 / 0)", +"lch(10 0 60 / 0.2)", "lch(10 0 60 / 0.2)", +"lch(10% 0% 60deg / 0.2)", "lch(10 0 60 / 0.2)", +"lch(10 0 60 / 1)", "lch(10 0 60)", +"lch(10% 0% 60deg / 1)", "lch(10 0 60)", +"lch(110 0 60)", "lch(110 0 60)", +"lch(110% 0% 60deg)", "lch(110 0 60)", +"lch(110 0 60 / 0)", "lch(110 0 60 / 0)", +"lch(110% 0% 60deg / 0)", "lch(110 0 60 / 0)", +"lch(110 0 60 / 0.2)", "lch(110 0 60 / 0.2)", +"lch(110% 0% 60deg / 0.2)", "lch(110 0 60 / 0.2)", +"lch(110 0 60 / 1)", "lch(110 0 60)", +"lch(110% 0% 60deg / 1)", "lch(110 0 60)", +"lch(-10 0 60)", "lch(-10 0 60)", +"lch(-10% 0% 60deg)", "lch(-10 0 60)", +"lch(-10 0 60 / 0)", "lch(-10 0 60 / 0)", +"lch(-10% 0% 60deg / 0)", "lch(-10 0 60 / 0)", +"lch(-10 0 60 / 0.2)", "lch(-10 0 60 / 0.2)", +"lch(-10% 0% 60deg / 0.2)", "lch(-10 0 60 / 0.2)", +"lch(-10 0 60 / 1)", "lch(-10 0 60)", +"lch(-10% 0% 60deg / 1)", "lch(-10 0 60)", +"lch(0 10 60)", "lch(0 10 60)", +"lch(0% 10% 60deg)", "lch(0 15 60)", +"lch(0 10 60 / 0)", "lch(0 10 60 / 0)", +"lch(0% 10% 60deg / 0)", "lch(0 15 60 / 0)", +"lch(0 10 60 / 0.2)", "lch(0 10 60 / 0.2)", +"lch(0% 10% 60deg / 0.2)", "lch(0 15 60 / 0.2)", +"lch(0 10 60 / 1)", "lch(0 10 60)", +"lch(0% 10% 60deg / 1)", "lch(0 15 60)", +"lch(10 10 60)", "lch(10 10 60)", +"lch(10% 10% 60deg)", "lch(10 15 60)", +"lch(10 10 60 / 0)", "lch(10 10 60 / 0)", +"lch(10% 10% 60deg / 0)", "lch(10 15 60 / 0)", +"lch(10 10 60 / 0.2)", "lch(10 10 60 / 0.2)", +"lch(10% 10% 60deg / 0.2)", "lch(10 15 60 / 0.2)", +"lch(10 10 60 / 1)", "lch(10 10 60)", +"lch(10% 10% 60deg / 1)", "lch(10 15 60)", +"lch(110 10 60)", "lch(110 10 60)", +"lch(110% 10% 60deg)", "lch(110 15 60)", +"lch(110 10 60 / 0)", "lch(110 10 60 / 0)", +"lch(110% 10% 60deg / 0)", "lch(110 15 60 / 0)", +"lch(110 10 60 / 0.2)", "lch(110 10 60 / 0.2)", +"lch(110% 10% 60deg / 0.2)", "lch(110 15 60 / 0.2)", +"lch(110 10 60 / 1)", "lch(110 10 60)", +"lch(110% 10% 60deg / 1)", "lch(110 15 60)", +"lch(-10 10 60)", "lch(-10 10 60)", +"lch(-10% 10% 60deg)", "lch(-10 15 60)", +"lch(-10 10 60 / 0)", "lch(-10 10 60 / 0)", +"lch(-10% 10% 60deg / 0)", "lch(-10 15 60 / 0)", +"lch(-10 10 60 / 0.2)", "lch(-10 10 60 / 0.2)", +"lch(-10% 10% 60deg / 0.2)", "lch(-10 15 60 / 0.2)", +"lch(-10 10 60 / 1)", "lch(-10 10 60)", +"lch(-10% 10% 60deg / 1)", "lch(-10 15 60)", +"lch(0 110 60)", "lch(0 110 60)", +"lch(0% 110% 60deg)", "lch(0 165 60)", +"lch(0 110 60 / 0)", "lch(0 110 60 / 0)", +"lch(0% 110% 60deg / 0)", "lch(0 165 60 / 0)", +"lch(0 110 60 / 0.2)", "lch(0 110 60 / 0.2)", +"lch(0% 110% 60deg / 0.2)", "lch(0 165 60 / 0.2)", +"lch(0 110 60 / 1)", "lch(0 110 60)", +"lch(0% 110% 60deg / 1)", "lch(0 165 60)", +"lch(10 110 60)", "lch(10 110 60)", +"lch(10% 110% 60deg)", "lch(10 165 60)", +"lch(10 110 60 / 0)", "lch(10 110 60 / 0)", +"lch(10% 110% 60deg / 0)", "lch(10 165 60 / 0)", +"lch(10 110 60 / 0.2)", "lch(10 110 60 / 0.2)", +"lch(10% 110% 60deg / 0.2)", "lch(10 165 60 / 0.2)", +"lch(10 110 60 / 1)", "lch(10 110 60)", +"lch(10% 110% 60deg / 1)", "lch(10 165 60)", +"lch(110 110 60)", "lch(110 110 60)", +"lch(110% 110% 60deg)", "lch(110 165 60)", +"lch(110 110 60 / 0)", "lch(110 110 60 / 0)", +"lch(110% 110% 60deg / 0)", "lch(110 165 60 / 0)", +"lch(110 110 60 / 0.2)", "lch(110 110 60 / 0.2)", +"lch(110% 110% 60deg / 0.2)", "lch(110 165 60 / 0.2)", +"lch(110 110 60 / 1)", "lch(110 110 60)", +"lch(110% 110% 60deg / 1)", "lch(110 165 60)", +"lch(-10 110 60)", "lch(-10 110 60)", +"lch(-10% 110% 60deg)", "lch(-10 165 60)", +"lch(-10 110 60 / 0)", "lch(-10 110 60 / 0)", +"lch(-10% 110% 60deg / 0)", "lch(-10 165 60 / 0)", +"lch(-10 110 60 / 0.2)", "lch(-10 110 60 / 0.2)", +"lch(-10% 110% 60deg / 0.2)", "lch(-10 165 60 / 0.2)", +"lch(-10 110 60 / 1)", "lch(-10 110 60)", +"lch(-10% 110% 60deg / 1)", "lch(-10 165 60)", +"lch(0 -10 60)", "lch(0 -10 60)", +"lch(0% -10% 60deg)", "lch(0 -15 60)", +"lch(0 -10 60 / 0)", "lch(0 -10 60 / 0)", +"lch(0% -10% 60deg / 0)", "lch(0 -15 60 / 0)", +"lch(0 -10 60 / 0.2)", "lch(0 -10 60 / 0.2)", +"lch(0% -10% 60deg / 0.2)", "lch(0 -15 60 / 0.2)", +"lch(0 -10 60 / 1)", "lch(0 -10 60)", +"lch(0% -10% 60deg / 1)", "lch(0 -15 60)", +"lch(10 -10 60)", "lch(10 -10 60)", +"lch(10% -10% 60deg)", "lch(10 -15 60)", +"lch(10 -10 60 / 0)", "lch(10 -10 60 / 0)", +"lch(10% -10% 60deg / 0)", "lch(10 -15 60 / 0)", +"lch(10 -10 60 / 0.2)", "lch(10 -10 60 / 0.2)", +"lch(10% -10% 60deg / 0.2)", "lch(10 -15 60 / 0.2)", +"lch(10 -10 60 / 1)", "lch(10 -10 60)", +"lch(10% -10% 60deg / 1)", "lch(10 -15 60)", +"lch(110 -10 60)", "lch(110 -10 60)", +"lch(110% -10% 60deg)", "lch(110 -15 60)", +"lch(110 -10 60 / 0)", "lch(110 -10 60 / 0)", +"lch(110% -10% 60deg / 0)", "lch(110 -15 60 / 0)", +"lch(110 -10 60 / 0.2)", "lch(110 -10 60 / 0.2)", +"lch(110% -10% 60deg / 0.2)", "lch(110 -15 60 / 0.2)", +"lch(110 -10 60 / 1)", "lch(110 -10 60)", +"lch(110% -10% 60deg / 1)", "lch(110 -15 60)", +"lch(-10 -10 60)", "lch(-10 -10 60)", +"lch(-10% -10% 60deg)", "lch(-10 -15 60)", +"lch(-10 -10 60 / 0)", "lch(-10 -10 60 / 0)", +"lch(-10% -10% 60deg / 0)", "lch(-10 -15 60 / 0)", +"lch(-10 -10 60 / 0.2)", "lch(-10 -10 60 / 0.2)", +"lch(-10% -10% 60deg / 0.2)", "lch(-10 -15 60 / 0.2)", +"lch(-10 -10 60 / 1)", "lch(-10 -10 60)", +"lch(-10% -10% 60deg / 1)", "lch(-10 -15 60)", +"lch(0 0 90)", "lch(0 0 90)", +"lch(0% 0% 90deg)", "lch(0 0 90)", +"lch(0 0 90 / 0)", "lch(0 0 90 / 0)", +"lch(0% 0% 90deg / 0)", "lch(0 0 90 / 0)", +"lch(0 0 90 / 0.2)", "lch(0 0 90 / 0.2)", +"lch(0% 0% 90deg / 0.2)", "lch(0 0 90 / 0.2)", +"lch(0 0 90 / 1)", "lch(0 0 90)", +"lch(0% 0% 90deg / 1)", "lch(0 0 90)", +"lch(10 0 90)", "lch(10 0 90)", +"lch(10% 0% 90deg)", "lch(10 0 90)", +"lch(10 0 90 / 0)", "lch(10 0 90 / 0)", +"lch(10% 0% 90deg / 0)", "lch(10 0 90 / 0)", +"lch(10 0 90 / 0.2)", "lch(10 0 90 / 0.2)", +"lch(10% 0% 90deg / 0.2)", "lch(10 0 90 / 0.2)", +"lch(10 0 90 / 1)", "lch(10 0 90)", +"lch(10% 0% 90deg / 1)", "lch(10 0 90)", +"lch(110 0 90)", "lch(110 0 90)", +"lch(110% 0% 90deg)", "lch(110 0 90)", +"lch(110 0 90 / 0)", "lch(110 0 90 / 0)", +"lch(110% 0% 90deg / 0)", "lch(110 0 90 / 0)", +"lch(110 0 90 / 0.2)", "lch(110 0 90 / 0.2)", +"lch(110% 0% 90deg / 0.2)", "lch(110 0 90 / 0.2)", +"lch(110 0 90 / 1)", "lch(110 0 90)", +"lch(110% 0% 90deg / 1)", "lch(110 0 90)", +"lch(-10 0 90)", "lch(-10 0 90)", +"lch(-10% 0% 90deg)", "lch(-10 0 90)", +"lch(-10 0 90 / 0)", "lch(-10 0 90 / 0)", +"lch(-10% 0% 90deg / 0)", "lch(-10 0 90 / 0)", +"lch(-10 0 90 / 0.2)", "lch(-10 0 90 / 0.2)", +"lch(-10% 0% 90deg / 0.2)", "lch(-10 0 90 / 0.2)", +"lch(-10 0 90 / 1)", "lch(-10 0 90)", +"lch(-10% 0% 90deg / 1)", "lch(-10 0 90)", +"lch(0 10 90)", "lch(0 10 90)", +"lch(0% 10% 90deg)", "lch(0 15 90)", +"lch(0 10 90 / 0)", "lch(0 10 90 / 0)", +"lch(0% 10% 90deg / 0)", "lch(0 15 90 / 0)", +"lch(0 10 90 / 0.2)", "lch(0 10 90 / 0.2)", +"lch(0% 10% 90deg / 0.2)", "lch(0 15 90 / 0.2)", +"lch(0 10 90 / 1)", "lch(0 10 90)", +"lch(0% 10% 90deg / 1)", "lch(0 15 90)", +"lch(10 10 90)", "lch(10 10 90)", +"lch(10% 10% 90deg)", "lch(10 15 90)", +"lch(10 10 90 / 0)", "lch(10 10 90 / 0)", +"lch(10% 10% 90deg / 0)", "lch(10 15 90 / 0)", +"lch(10 10 90 / 0.2)", "lch(10 10 90 / 0.2)", +"lch(10% 10% 90deg / 0.2)", "lch(10 15 90 / 0.2)", +"lch(10 10 90 / 1)", "lch(10 10 90)", +"lch(10% 10% 90deg / 1)", "lch(10 15 90)", +"lch(110 10 90)", "lch(110 10 90)", +"lch(110% 10% 90deg)", "lch(110 15 90)", +"lch(110 10 90 / 0)", "lch(110 10 90 / 0)", +"lch(110% 10% 90deg / 0)", "lch(110 15 90 / 0)", +"lch(110 10 90 / 0.2)", "lch(110 10 90 / 0.2)", +"lch(110% 10% 90deg / 0.2)", "lch(110 15 90 / 0.2)", +"lch(110 10 90 / 1)", "lch(110 10 90)", +"lch(110% 10% 90deg / 1)", "lch(110 15 90)", +"lch(-10 10 90)", "lch(-10 10 90)", +"lch(-10% 10% 90deg)", "lch(-10 15 90)", +"lch(-10 10 90 / 0)", "lch(-10 10 90 / 0)", +"lch(-10% 10% 90deg / 0)", "lch(-10 15 90 / 0)", +"lch(-10 10 90 / 0.2)", "lch(-10 10 90 / 0.2)", +"lch(-10% 10% 90deg / 0.2)", "lch(-10 15 90 / 0.2)", +"lch(-10 10 90 / 1)", "lch(-10 10 90)", +"lch(-10% 10% 90deg / 1)", "lch(-10 15 90)", +"lch(0 110 90)", "lch(0 110 90)", +"lch(0% 110% 90deg)", "lch(0 165 90)", +"lch(0 110 90 / 0)", "lch(0 110 90 / 0)", +"lch(0% 110% 90deg / 0)", "lch(0 165 90 / 0)", +"lch(0 110 90 / 0.2)", "lch(0 110 90 / 0.2)", +"lch(0% 110% 90deg / 0.2)", "lch(0 165 90 / 0.2)", +"lch(0 110 90 / 1)", "lch(0 110 90)", +"lch(0% 110% 90deg / 1)", "lch(0 165 90)", +"lch(10 110 90)", "lch(10 110 90)", +"lch(10% 110% 90deg)", "lch(10 165 90)", +"lch(10 110 90 / 0)", "lch(10 110 90 / 0)", +"lch(10% 110% 90deg / 0)", "lch(10 165 90 / 0)", +"lch(10 110 90 / 0.2)", "lch(10 110 90 / 0.2)", +"lch(10% 110% 90deg / 0.2)", "lch(10 165 90 / 0.2)", +"lch(10 110 90 / 1)", "lch(10 110 90)", +"lch(10% 110% 90deg / 1)", "lch(10 165 90)", +"lch(110 110 90)", "lch(110 110 90)", +"lch(110% 110% 90deg)", "lch(110 165 90)", +"lch(110 110 90 / 0)", "lch(110 110 90 / 0)", +"lch(110% 110% 90deg / 0)", "lch(110 165 90 / 0)", +"lch(110 110 90 / 0.2)", "lch(110 110 90 / 0.2)", +"lch(110% 110% 90deg / 0.2)", "lch(110 165 90 / 0.2)", +"lch(110 110 90 / 1)", "lch(110 110 90)", +"lch(110% 110% 90deg / 1)", "lch(110 165 90)", +"lch(-10 110 90)", "lch(-10 110 90)", +"lch(-10% 110% 90deg)", "lch(-10 165 90)", +"lch(-10 110 90 / 0)", "lch(-10 110 90 / 0)", +"lch(-10% 110% 90deg / 0)", "lch(-10 165 90 / 0)", +"lch(-10 110 90 / 0.2)", "lch(-10 110 90 / 0.2)", +"lch(-10% 110% 90deg / 0.2)", "lch(-10 165 90 / 0.2)", +"lch(-10 110 90 / 1)", "lch(-10 110 90)", +"lch(-10% 110% 90deg / 1)", "lch(-10 165 90)", +"lch(0 -10 90)", "lch(0 -10 90)", +"lch(0% -10% 90deg)", "lch(0 -15 90)", +"lch(0 -10 90 / 0)", "lch(0 -10 90 / 0)", +"lch(0% -10% 90deg / 0)", "lch(0 -15 90 / 0)", +"lch(0 -10 90 / 0.2)", "lch(0 -10 90 / 0.2)", +"lch(0% -10% 90deg / 0.2)", "lch(0 -15 90 / 0.2)", +"lch(0 -10 90 / 1)", "lch(0 -10 90)", +"lch(0% -10% 90deg / 1)", "lch(0 -15 90)", +"lch(10 -10 90)", "lch(10 -10 90)", +"lch(10% -10% 90deg)", "lch(10 -15 90)", +"lch(10 -10 90 / 0)", "lch(10 -10 90 / 0)", +"lch(10% -10% 90deg / 0)", "lch(10 -15 90 / 0)", +"lch(10 -10 90 / 0.2)", "lch(10 -10 90 / 0.2)", +"lch(10% -10% 90deg / 0.2)", "lch(10 -15 90 / 0.2)", +"lch(10 -10 90 / 1)", "lch(10 -10 90)", +"lch(10% -10% 90deg / 1)", "lch(10 -15 90)", +"lch(110 -10 90)", "lch(110 -10 90)", +"lch(110% -10% 90deg)", "lch(110 -15 90)", +"lch(110 -10 90 / 0)", "lch(110 -10 90 / 0)", +"lch(110% -10% 90deg / 0)", "lch(110 -15 90 / 0)", +"lch(110 -10 90 / 0.2)", "lch(110 -10 90 / 0.2)", +"lch(110% -10% 90deg / 0.2)", "lch(110 -15 90 / 0.2)", +"lch(110 -10 90 / 1)", "lch(110 -10 90)", +"lch(110% -10% 90deg / 1)", "lch(110 -15 90)", +"lch(-10 -10 90)", "lch(-10 -10 90)", +"lch(-10% -10% 90deg)", "lch(-10 -15 90)", +"lch(-10 -10 90 / 0)", "lch(-10 -10 90 / 0)", +"lch(-10% -10% 90deg / 0)", "lch(-10 -15 90 / 0)", +"lch(-10 -10 90 / 0.2)", "lch(-10 -10 90 / 0.2)", +"lch(-10% -10% 90deg / 0.2)", "lch(-10 -15 90 / 0.2)", +"lch(-10 -10 90 / 1)", "lch(-10 -10 90)", +"lch(-10% -10% 90deg / 1)", "lch(-10 -15 90)", +"lch(0 0 120)", "lch(0 0 120)", +"lch(0% 0% 120deg)", "lch(0 0 120)", +"lch(0 0 120 / 0)", "lch(0 0 120 / 0)", +"lch(0% 0% 120deg / 0)", "lch(0 0 120 / 0)", +"lch(0 0 120 / 0.2)", "lch(0 0 120 / 0.2)", +"lch(0% 0% 120deg / 0.2)", "lch(0 0 120 / 0.2)", +"lch(0 0 120 / 1)", "lch(0 0 120)", +"lch(0% 0% 120deg / 1)", "lch(0 0 120)", +"lch(10 0 120)", "lch(10 0 120)", +"lch(10% 0% 120deg)", "lch(10 0 120)", +"lch(10 0 120 / 0)", "lch(10 0 120 / 0)", +"lch(10% 0% 120deg / 0)", "lch(10 0 120 / 0)", +"lch(10 0 120 / 0.2)", "lch(10 0 120 / 0.2)", +"lch(10% 0% 120deg / 0.2)", "lch(10 0 120 / 0.2)", +"lch(10 0 120 / 1)", "lch(10 0 120)", +"lch(10% 0% 120deg / 1)", "lch(10 0 120)", +"lch(110 0 120)", "lch(110 0 120)", +"lch(110% 0% 120deg)", "lch(110 0 120)", +"lch(110 0 120 / 0)", "lch(110 0 120 / 0)", +"lch(110% 0% 120deg / 0)", "lch(110 0 120 / 0)", +"lch(110 0 120 / 0.2)", "lch(110 0 120 / 0.2)", +"lch(110% 0% 120deg / 0.2)", "lch(110 0 120 / 0.2)", +"lch(110 0 120 / 1)", "lch(110 0 120)", +"lch(110% 0% 120deg / 1)", "lch(110 0 120)", +"lch(-10 0 120)", "lch(-10 0 120)", +"lch(-10% 0% 120deg)", "lch(-10 0 120)", +"lch(-10 0 120 / 0)", "lch(-10 0 120 / 0)", +"lch(-10% 0% 120deg / 0)", "lch(-10 0 120 / 0)", +"lch(-10 0 120 / 0.2)", "lch(-10 0 120 / 0.2)", +"lch(-10% 0% 120deg / 0.2)", "lch(-10 0 120 / 0.2)", +"lch(-10 0 120 / 1)", "lch(-10 0 120)", +"lch(-10% 0% 120deg / 1)", "lch(-10 0 120)", +"lch(0 10 120)", "lch(0 10 120)", +"lch(0% 10% 120deg)", "lch(0 15 120)", +"lch(0 10 120 / 0)", "lch(0 10 120 / 0)", +"lch(0% 10% 120deg / 0)", "lch(0 15 120 / 0)", +"lch(0 10 120 / 0.2)", "lch(0 10 120 / 0.2)", +"lch(0% 10% 120deg / 0.2)", "lch(0 15 120 / 0.2)", +"lch(0 10 120 / 1)", "lch(0 10 120)", +"lch(0% 10% 120deg / 1)", "lch(0 15 120)", +"lch(10 10 120)", "lch(10 10 120)", +"lch(10% 10% 120deg)", "lch(10 15 120)", +"lch(10 10 120 / 0)", "lch(10 10 120 / 0)", +"lch(10% 10% 120deg / 0)", "lch(10 15 120 / 0)", +"lch(10 10 120 / 0.2)", "lch(10 10 120 / 0.2)", +"lch(10% 10% 120deg / 0.2)", "lch(10 15 120 / 0.2)", +"lch(10 10 120 / 1)", "lch(10 10 120)", +"lch(10% 10% 120deg / 1)", "lch(10 15 120)", +"lch(110 10 120)", "lch(110 10 120)", +"lch(110% 10% 120deg)", "lch(110 15 120)", +"lch(110 10 120 / 0)", "lch(110 10 120 / 0)", +"lch(110% 10% 120deg / 0)", "lch(110 15 120 / 0)", +"lch(110 10 120 / 0.2)", "lch(110 10 120 / 0.2)", +"lch(110% 10% 120deg / 0.2)", "lch(110 15 120 / 0.2)", +"lch(110 10 120 / 1)", "lch(110 10 120)", +"lch(110% 10% 120deg / 1)", "lch(110 15 120)", +"lch(-10 10 120)", "lch(-10 10 120)", +"lch(-10% 10% 120deg)", "lch(-10 15 120)", +"lch(-10 10 120 / 0)", "lch(-10 10 120 / 0)", +"lch(-10% 10% 120deg / 0)", "lch(-10 15 120 / 0)", +"lch(-10 10 120 / 0.2)", "lch(-10 10 120 / 0.2)", +"lch(-10% 10% 120deg / 0.2)", "lch(-10 15 120 / 0.2)", +"lch(-10 10 120 / 1)", "lch(-10 10 120)", +"lch(-10% 10% 120deg / 1)", "lch(-10 15 120)", +"lch(0 110 120)", "lch(0 110 120)", +"lch(0% 110% 120deg)", "lch(0 165 120)", +"lch(0 110 120 / 0)", "lch(0 110 120 / 0)", +"lch(0% 110% 120deg / 0)", "lch(0 165 120 / 0)", +"lch(0 110 120 / 0.2)", "lch(0 110 120 / 0.2)", +"lch(0% 110% 120deg / 0.2)", "lch(0 165 120 / 0.2)", +"lch(0 110 120 / 1)", "lch(0 110 120)", +"lch(0% 110% 120deg / 1)", "lch(0 165 120)", +"lch(10 110 120)", "lch(10 110 120)", +"lch(10% 110% 120deg)", "lch(10 165 120)", +"lch(10 110 120 / 0)", "lch(10 110 120 / 0)", +"lch(10% 110% 120deg / 0)", "lch(10 165 120 / 0)", +"lch(10 110 120 / 0.2)", "lch(10 110 120 / 0.2)", +"lch(10% 110% 120deg / 0.2)", "lch(10 165 120 / 0.2)", +"lch(10 110 120 / 1)", "lch(10 110 120)", +"lch(10% 110% 120deg / 1)", "lch(10 165 120)", +"lch(110 110 120)", "lch(110 110 120)", +"lch(110% 110% 120deg)", "lch(110 165 120)", +"lch(110 110 120 / 0)", "lch(110 110 120 / 0)", +"lch(110% 110% 120deg / 0)", "lch(110 165 120 / 0)", +"lch(110 110 120 / 0.2)", "lch(110 110 120 / 0.2)", +"lch(110% 110% 120deg / 0.2)", "lch(110 165 120 / 0.2)", +"lch(110 110 120 / 1)", "lch(110 110 120)", +"lch(110% 110% 120deg / 1)", "lch(110 165 120)", +"lch(-10 110 120)", "lch(-10 110 120)", +"lch(-10% 110% 120deg)", "lch(-10 165 120)", +"lch(-10 110 120 / 0)", "lch(-10 110 120 / 0)", +"lch(-10% 110% 120deg / 0)", "lch(-10 165 120 / 0)", +"lch(-10 110 120 / 0.2)", "lch(-10 110 120 / 0.2)", +"lch(-10% 110% 120deg / 0.2)", "lch(-10 165 120 / 0.2)", +"lch(-10 110 120 / 1)", "lch(-10 110 120)", +"lch(-10% 110% 120deg / 1)", "lch(-10 165 120)", +"lch(0 -10 120)", "lch(0 -10 120)", +"lch(0% -10% 120deg)", "lch(0 -15 120)", +"lch(0 -10 120 / 0)", "lch(0 -10 120 / 0)", +"lch(0% -10% 120deg / 0)", "lch(0 -15 120 / 0)", +"lch(0 -10 120 / 0.2)", "lch(0 -10 120 / 0.2)", +"lch(0% -10% 120deg / 0.2)", "lch(0 -15 120 / 0.2)", +"lch(0 -10 120 / 1)", "lch(0 -10 120)", +"lch(0% -10% 120deg / 1)", "lch(0 -15 120)", +"lch(10 -10 120)", "lch(10 -10 120)", +"lch(10% -10% 120deg)", "lch(10 -15 120)", +"lch(10 -10 120 / 0)", "lch(10 -10 120 / 0)", +"lch(10% -10% 120deg / 0)", "lch(10 -15 120 / 0)", +"lch(10 -10 120 / 0.2)", "lch(10 -10 120 / 0.2)", +"lch(10% -10% 120deg / 0.2)", "lch(10 -15 120 / 0.2)", +"lch(10 -10 120 / 1)", "lch(10 -10 120)", +"lch(10% -10% 120deg / 1)", "lch(10 -15 120)", +"lch(110 -10 120)", "lch(110 -10 120)", +"lch(110% -10% 120deg)", "lch(110 -15 120)", +"lch(110 -10 120 / 0)", "lch(110 -10 120 / 0)", +"lch(110% -10% 120deg / 0)", "lch(110 -15 120 / 0)", +"lch(110 -10 120 / 0.2)", "lch(110 -10 120 / 0.2)", +"lch(110% -10% 120deg / 0.2)", "lch(110 -15 120 / 0.2)", +"lch(110 -10 120 / 1)", "lch(110 -10 120)", +"lch(110% -10% 120deg / 1)", "lch(110 -15 120)", +"lch(-10 -10 120)", "lch(-10 -10 120)", +"lch(-10% -10% 120deg)", "lch(-10 -15 120)", +"lch(-10 -10 120 / 0)", "lch(-10 -10 120 / 0)", +"lch(-10% -10% 120deg / 0)", "lch(-10 -15 120 / 0)", +"lch(-10 -10 120 / 0.2)", "lch(-10 -10 120 / 0.2)", +"lch(-10% -10% 120deg / 0.2)", "lch(-10 -15 120 / 0.2)", +"lch(-10 -10 120 / 1)", "lch(-10 -10 120)", +"lch(-10% -10% 120deg / 1)", "lch(-10 -15 120)", +"lch(0 0 180)", "lch(0 0 180)", +"lch(0% 0% 180deg)", "lch(0 0 180)", +"lch(0 0 180 / 0)", "lch(0 0 180 / 0)", +"lch(0% 0% 180deg / 0)", "lch(0 0 180 / 0)", +"lch(0 0 180 / 0.2)", "lch(0 0 180 / 0.2)", +"lch(0% 0% 180deg / 0.2)", "lch(0 0 180 / 0.2)", +"lch(0 0 180 / 1)", "lch(0 0 180)", +"lch(0% 0% 180deg / 1)", "lch(0 0 180)", +"lch(10 0 180)", "lch(10 0 180)", +"lch(10% 0% 180deg)", "lch(10 0 180)", +"lch(10 0 180 / 0)", "lch(10 0 180 / 0)", +"lch(10% 0% 180deg / 0)", "lch(10 0 180 / 0)", +"lch(10 0 180 / 0.2)", "lch(10 0 180 / 0.2)", +"lch(10% 0% 180deg / 0.2)", "lch(10 0 180 / 0.2)", +"lch(10 0 180 / 1)", "lch(10 0 180)", +"lch(10% 0% 180deg / 1)", "lch(10 0 180)", +"lch(110 0 180)", "lch(110 0 180)", +"lch(110% 0% 180deg)", "lch(110 0 180)", +"lch(110 0 180 / 0)", "lch(110 0 180 / 0)", +"lch(110% 0% 180deg / 0)", "lch(110 0 180 / 0)", +"lch(110 0 180 / 0.2)", "lch(110 0 180 / 0.2)", +"lch(110% 0% 180deg / 0.2)", "lch(110 0 180 / 0.2)", +"lch(110 0 180 / 1)", "lch(110 0 180)", +"lch(110% 0% 180deg / 1)", "lch(110 0 180)", +"lch(-10 0 180)", "lch(-10 0 180)", +"lch(-10% 0% 180deg)", "lch(-10 0 180)", +"lch(-10 0 180 / 0)", "lch(-10 0 180 / 0)", +"lch(-10% 0% 180deg / 0)", "lch(-10 0 180 / 0)", +"lch(-10 0 180 / 0.2)", "lch(-10 0 180 / 0.2)", +"lch(-10% 0% 180deg / 0.2)", "lch(-10 0 180 / 0.2)", +"lch(-10 0 180 / 1)", "lch(-10 0 180)", +"lch(-10% 0% 180deg / 1)", "lch(-10 0 180)", +"lch(0 10 180)", "lch(0 10 180)", +"lch(0% 10% 180deg)", "lch(0 15 180)", +"lch(0 10 180 / 0)", "lch(0 10 180 / 0)", +"lch(0% 10% 180deg / 0)", "lch(0 15 180 / 0)", +"lch(0 10 180 / 0.2)", "lch(0 10 180 / 0.2)", +"lch(0% 10% 180deg / 0.2)", "lch(0 15 180 / 0.2)", +"lch(0 10 180 / 1)", "lch(0 10 180)", +"lch(0% 10% 180deg / 1)", "lch(0 15 180)", +"lch(10 10 180)", "lch(10 10 180)", +"lch(10% 10% 180deg)", "lch(10 15 180)", +"lch(10 10 180 / 0)", "lch(10 10 180 / 0)", +"lch(10% 10% 180deg / 0)", "lch(10 15 180 / 0)", +"lch(10 10 180 / 0.2)", "lch(10 10 180 / 0.2)", +"lch(10% 10% 180deg / 0.2)", "lch(10 15 180 / 0.2)", +"lch(10 10 180 / 1)", "lch(10 10 180)", +"lch(10% 10% 180deg / 1)", "lch(10 15 180)", +"lch(110 10 180)", "lch(110 10 180)", +"lch(110% 10% 180deg)", "lch(110 15 180)", +"lch(110 10 180 / 0)", "lch(110 10 180 / 0)", +"lch(110% 10% 180deg / 0)", "lch(110 15 180 / 0)", +"lch(110 10 180 / 0.2)", "lch(110 10 180 / 0.2)", +"lch(110% 10% 180deg / 0.2)", "lch(110 15 180 / 0.2)", +"lch(110 10 180 / 1)", "lch(110 10 180)", +"lch(110% 10% 180deg / 1)", "lch(110 15 180)", +"lch(-10 10 180)", "lch(-10 10 180)", +"lch(-10% 10% 180deg)", "lch(-10 15 180)", +"lch(-10 10 180 / 0)", "lch(-10 10 180 / 0)", +"lch(-10% 10% 180deg / 0)", "lch(-10 15 180 / 0)", +"lch(-10 10 180 / 0.2)", "lch(-10 10 180 / 0.2)", +"lch(-10% 10% 180deg / 0.2)", "lch(-10 15 180 / 0.2)", +"lch(-10 10 180 / 1)", "lch(-10 10 180)", +"lch(-10% 10% 180deg / 1)", "lch(-10 15 180)", +"lch(0 110 180)", "lch(0 110 180)", +"lch(0% 110% 180deg)", "lch(0 165 180)", +"lch(0 110 180 / 0)", "lch(0 110 180 / 0)", +"lch(0% 110% 180deg / 0)", "lch(0 165 180 / 0)", +"lch(0 110 180 / 0.2)", "lch(0 110 180 / 0.2)", +"lch(0% 110% 180deg / 0.2)", "lch(0 165 180 / 0.2)", +"lch(0 110 180 / 1)", "lch(0 110 180)", +"lch(0% 110% 180deg / 1)", "lch(0 165 180)", +"lch(10 110 180)", "lch(10 110 180)", +"lch(10% 110% 180deg)", "lch(10 165 180)", +"lch(10 110 180 / 0)", "lch(10 110 180 / 0)", +"lch(10% 110% 180deg / 0)", "lch(10 165 180 / 0)", +"lch(10 110 180 / 0.2)", "lch(10 110 180 / 0.2)", +"lch(10% 110% 180deg / 0.2)", "lch(10 165 180 / 0.2)", +"lch(10 110 180 / 1)", "lch(10 110 180)", +"lch(10% 110% 180deg / 1)", "lch(10 165 180)", +"lch(110 110 180)", "lch(110 110 180)", +"lch(110% 110% 180deg)", "lch(110 165 180)", +"lch(110 110 180 / 0)", "lch(110 110 180 / 0)", +"lch(110% 110% 180deg / 0)", "lch(110 165 180 / 0)", +"lch(110 110 180 / 0.2)", "lch(110 110 180 / 0.2)", +"lch(110% 110% 180deg / 0.2)", "lch(110 165 180 / 0.2)", +"lch(110 110 180 / 1)", "lch(110 110 180)", +"lch(110% 110% 180deg / 1)", "lch(110 165 180)", +"lch(-10 110 180)", "lch(-10 110 180)", +"lch(-10% 110% 180deg)", "lch(-10 165 180)", +"lch(-10 110 180 / 0)", "lch(-10 110 180 / 0)", +"lch(-10% 110% 180deg / 0)", "lch(-10 165 180 / 0)", +"lch(-10 110 180 / 0.2)", "lch(-10 110 180 / 0.2)", +"lch(-10% 110% 180deg / 0.2)", "lch(-10 165 180 / 0.2)", +"lch(-10 110 180 / 1)", "lch(-10 110 180)", +"lch(-10% 110% 180deg / 1)", "lch(-10 165 180)", +"lch(0 -10 180)", "lch(0 -10 180)", +"lch(0% -10% 180deg)", "lch(0 -15 180)", +"lch(0 -10 180 / 0)", "lch(0 -10 180 / 0)", +"lch(0% -10% 180deg / 0)", "lch(0 -15 180 / 0)", +"lch(0 -10 180 / 0.2)", "lch(0 -10 180 / 0.2)", +"lch(0% -10% 180deg / 0.2)", "lch(0 -15 180 / 0.2)", +"lch(0 -10 180 / 1)", "lch(0 -10 180)", +"lch(0% -10% 180deg / 1)", "lch(0 -15 180)", +"lch(10 -10 180)", "lch(10 -10 180)", +"lch(10% -10% 180deg)", "lch(10 -15 180)", +"lch(10 -10 180 / 0)", "lch(10 -10 180 / 0)", +"lch(10% -10% 180deg / 0)", "lch(10 -15 180 / 0)", +"lch(10 -10 180 / 0.2)", "lch(10 -10 180 / 0.2)", +"lch(10% -10% 180deg / 0.2)", "lch(10 -15 180 / 0.2)", +"lch(10 -10 180 / 1)", "lch(10 -10 180)", +"lch(10% -10% 180deg / 1)", "lch(10 -15 180)", +"lch(110 -10 180)", "lch(110 -10 180)", +"lch(110% -10% 180deg)", "lch(110 -15 180)", +"lch(110 -10 180 / 0)", "lch(110 -10 180 / 0)", +"lch(110% -10% 180deg / 0)", "lch(110 -15 180 / 0)", +"lch(110 -10 180 / 0.2)", "lch(110 -10 180 / 0.2)", +"lch(110% -10% 180deg / 0.2)", "lch(110 -15 180 / 0.2)", +"lch(110 -10 180 / 1)", "lch(110 -10 180)", +"lch(110% -10% 180deg / 1)", "lch(110 -15 180)", +"lch(-10 -10 180)", "lch(-10 -10 180)", +"lch(-10% -10% 180deg)", "lch(-10 -15 180)", +"lch(-10 -10 180 / 0)", "lch(-10 -10 180 / 0)", +"lch(-10% -10% 180deg / 0)", "lch(-10 -15 180 / 0)", +"lch(-10 -10 180 / 0.2)", "lch(-10 -10 180 / 0.2)", +"lch(-10% -10% 180deg / 0.2)", "lch(-10 -15 180 / 0.2)", +"lch(-10 -10 180 / 1)", "lch(-10 -10 180)", +"lch(-10% -10% 180deg / 1)", "lch(-10 -15 180)", +"lch(0 0 210)", "lch(0 0 210)", +"lch(0% 0% 210deg)", "lch(0 0 210)", +"lch(0 0 210 / 0)", "lch(0 0 210 / 0)", +"lch(0% 0% 210deg / 0)", "lch(0 0 210 / 0)", +"lch(0 0 210 / 0.2)", "lch(0 0 210 / 0.2)", +"lch(0% 0% 210deg / 0.2)", "lch(0 0 210 / 0.2)", +"lch(0 0 210 / 1)", "lch(0 0 210)", +"lch(0% 0% 210deg / 1)", "lch(0 0 210)", +"lch(10 0 210)", "lch(10 0 210)", +"lch(10% 0% 210deg)", "lch(10 0 210)", +"lch(10 0 210 / 0)", "lch(10 0 210 / 0)", +"lch(10% 0% 210deg / 0)", "lch(10 0 210 / 0)", +"lch(10 0 210 / 0.2)", "lch(10 0 210 / 0.2)", +"lch(10% 0% 210deg / 0.2)", "lch(10 0 210 / 0.2)", +"lch(10 0 210 / 1)", "lch(10 0 210)", +"lch(10% 0% 210deg / 1)", "lch(10 0 210)", +"lch(110 0 210)", "lch(110 0 210)", +"lch(110% 0% 210deg)", "lch(110 0 210)", +"lch(110 0 210 / 0)", "lch(110 0 210 / 0)", +"lch(110% 0% 210deg / 0)", "lch(110 0 210 / 0)", +"lch(110 0 210 / 0.2)", "lch(110 0 210 / 0.2)", +"lch(110% 0% 210deg / 0.2)", "lch(110 0 210 / 0.2)", +"lch(110 0 210 / 1)", "lch(110 0 210)", +"lch(110% 0% 210deg / 1)", "lch(110 0 210)", +"lch(-10 0 210)", "lch(-10 0 210)", +"lch(-10% 0% 210deg)", "lch(-10 0 210)", +"lch(-10 0 210 / 0)", "lch(-10 0 210 / 0)", +"lch(-10% 0% 210deg / 0)", "lch(-10 0 210 / 0)", +"lch(-10 0 210 / 0.2)", "lch(-10 0 210 / 0.2)", +"lch(-10% 0% 210deg / 0.2)", "lch(-10 0 210 / 0.2)", +"lch(-10 0 210 / 1)", "lch(-10 0 210)", +"lch(-10% 0% 210deg / 1)", "lch(-10 0 210)", +"lch(0 10 210)", "lch(0 10 210)", +"lch(0% 10% 210deg)", "lch(0 15 210)", +"lch(0 10 210 / 0)", "lch(0 10 210 / 0)", +"lch(0% 10% 210deg / 0)", "lch(0 15 210 / 0)", +"lch(0 10 210 / 0.2)", "lch(0 10 210 / 0.2)", +"lch(0% 10% 210deg / 0.2)", "lch(0 15 210 / 0.2)", +"lch(0 10 210 / 1)", "lch(0 10 210)", +"lch(0% 10% 210deg / 1)", "lch(0 15 210)", +"lch(10 10 210)", "lch(10 10 210)", +"lch(10% 10% 210deg)", "lch(10 15 210)", +"lch(10 10 210 / 0)", "lch(10 10 210 / 0)", +"lch(10% 10% 210deg / 0)", "lch(10 15 210 / 0)", +"lch(10 10 210 / 0.2)", "lch(10 10 210 / 0.2)", +"lch(10% 10% 210deg / 0.2)", "lch(10 15 210 / 0.2)", +"lch(10 10 210 / 1)", "lch(10 10 210)", +"lch(10% 10% 210deg / 1)", "lch(10 15 210)", +"lch(110 10 210)", "lch(110 10 210)", +"lch(110% 10% 210deg)", "lch(110 15 210)", +"lch(110 10 210 / 0)", "lch(110 10 210 / 0)", +"lch(110% 10% 210deg / 0)", "lch(110 15 210 / 0)", +"lch(110 10 210 / 0.2)", "lch(110 10 210 / 0.2)", +"lch(110% 10% 210deg / 0.2)", "lch(110 15 210 / 0.2)", +"lch(110 10 210 / 1)", "lch(110 10 210)", +"lch(110% 10% 210deg / 1)", "lch(110 15 210)", +"lch(-10 10 210)", "lch(-10 10 210)", +"lch(-10% 10% 210deg)", "lch(-10 15 210)", +"lch(-10 10 210 / 0)", "lch(-10 10 210 / 0)", +"lch(-10% 10% 210deg / 0)", "lch(-10 15 210 / 0)", +"lch(-10 10 210 / 0.2)", "lch(-10 10 210 / 0.2)", +"lch(-10% 10% 210deg / 0.2)", "lch(-10 15 210 / 0.2)", +"lch(-10 10 210 / 1)", "lch(-10 10 210)", +"lch(-10% 10% 210deg / 1)", "lch(-10 15 210)", +"lch(0 110 210)", "lch(0 110 210)", +"lch(0% 110% 210deg)", "lch(0 165 210)", +"lch(0 110 210 / 0)", "lch(0 110 210 / 0)", +"lch(0% 110% 210deg / 0)", "lch(0 165 210 / 0)", +"lch(0 110 210 / 0.2)", "lch(0 110 210 / 0.2)", +"lch(0% 110% 210deg / 0.2)", "lch(0 165 210 / 0.2)", +"lch(0 110 210 / 1)", "lch(0 110 210)", +"lch(0% 110% 210deg / 1)", "lch(0 165 210)", +"lch(10 110 210)", "lch(10 110 210)", +"lch(10% 110% 210deg)", "lch(10 165 210)", +"lch(10 110 210 / 0)", "lch(10 110 210 / 0)", +"lch(10% 110% 210deg / 0)", "lch(10 165 210 / 0)", +"lch(10 110 210 / 0.2)", "lch(10 110 210 / 0.2)", +"lch(10% 110% 210deg / 0.2)", "lch(10 165 210 / 0.2)", +"lch(10 110 210 / 1)", "lch(10 110 210)", +"lch(10% 110% 210deg / 1)", "lch(10 165 210)", +"lch(110 110 210)", "lch(110 110 210)", +"lch(110% 110% 210deg)", "lch(110 165 210)", +"lch(110 110 210 / 0)", "lch(110 110 210 / 0)", +"lch(110% 110% 210deg / 0)", "lch(110 165 210 / 0)", +"lch(110 110 210 / 0.2)", "lch(110 110 210 / 0.2)", +"lch(110% 110% 210deg / 0.2)", "lch(110 165 210 / 0.2)", +"lch(110 110 210 / 1)", "lch(110 110 210)", +"lch(110% 110% 210deg / 1)", "lch(110 165 210)", +"lch(-10 110 210)", "lch(-10 110 210)", +"lch(-10% 110% 210deg)", "lch(-10 165 210)", +"lch(-10 110 210 / 0)", "lch(-10 110 210 / 0)", +"lch(-10% 110% 210deg / 0)", "lch(-10 165 210 / 0)", +"lch(-10 110 210 / 0.2)", "lch(-10 110 210 / 0.2)", +"lch(-10% 110% 210deg / 0.2)", "lch(-10 165 210 / 0.2)", +"lch(-10 110 210 / 1)", "lch(-10 110 210)", +"lch(-10% 110% 210deg / 1)", "lch(-10 165 210)", +"lch(0 -10 210)", "lch(0 -10 210)", +"lch(0% -10% 210deg)", "lch(0 -15 210)", +"lch(0 -10 210 / 0)", "lch(0 -10 210 / 0)", +"lch(0% -10% 210deg / 0)", "lch(0 -15 210 / 0)", +"lch(0 -10 210 / 0.2)", "lch(0 -10 210 / 0.2)", +"lch(0% -10% 210deg / 0.2)", "lch(0 -15 210 / 0.2)", +"lch(0 -10 210 / 1)", "lch(0 -10 210)", +"lch(0% -10% 210deg / 1)", "lch(0 -15 210)", +"lch(10 -10 210)", "lch(10 -10 210)", +"lch(10% -10% 210deg)", "lch(10 -15 210)", +"lch(10 -10 210 / 0)", "lch(10 -10 210 / 0)", +"lch(10% -10% 210deg / 0)", "lch(10 -15 210 / 0)", +"lch(10 -10 210 / 0.2)", "lch(10 -10 210 / 0.2)", +"lch(10% -10% 210deg / 0.2)", "lch(10 -15 210 / 0.2)", +"lch(10 -10 210 / 1)", "lch(10 -10 210)", +"lch(10% -10% 210deg / 1)", "lch(10 -15 210)", +"lch(110 -10 210)", "lch(110 -10 210)", +"lch(110% -10% 210deg)", "lch(110 -15 210)", +"lch(110 -10 210 / 0)", "lch(110 -10 210 / 0)", +"lch(110% -10% 210deg / 0)", "lch(110 -15 210 / 0)", +"lch(110 -10 210 / 0.2)", "lch(110 -10 210 / 0.2)", +"lch(110% -10% 210deg / 0.2)", "lch(110 -15 210 / 0.2)", +"lch(110 -10 210 / 1)", "lch(110 -10 210)", +"lch(110% -10% 210deg / 1)", "lch(110 -15 210)", +"lch(-10 -10 210)", "lch(-10 -10 210)", +"lch(-10% -10% 210deg)", "lch(-10 -15 210)", +"lch(-10 -10 210 / 0)", "lch(-10 -10 210 / 0)", +"lch(-10% -10% 210deg / 0)", "lch(-10 -15 210 / 0)", +"lch(-10 -10 210 / 0.2)", "lch(-10 -10 210 / 0.2)", +"lch(-10% -10% 210deg / 0.2)", "lch(-10 -15 210 / 0.2)", +"lch(-10 -10 210 / 1)", "lch(-10 -10 210)", +"lch(-10% -10% 210deg / 1)", "lch(-10 -15 210)", +"lch(0 0 240)", "lch(0 0 240)", +"lch(0% 0% 240deg)", "lch(0 0 240)", +"lch(0 0 240 / 0)", "lch(0 0 240 / 0)", +"lch(0% 0% 240deg / 0)", "lch(0 0 240 / 0)", +"lch(0 0 240 / 0.2)", "lch(0 0 240 / 0.2)", +"lch(0% 0% 240deg / 0.2)", "lch(0 0 240 / 0.2)", +"lch(0 0 240 / 1)", "lch(0 0 240)", +"lch(0% 0% 240deg / 1)", "lch(0 0 240)", +"lch(10 0 240)", "lch(10 0 240)", +"lch(10% 0% 240deg)", "lch(10 0 240)", +"lch(10 0 240 / 0)", "lch(10 0 240 / 0)", +"lch(10% 0% 240deg / 0)", "lch(10 0 240 / 0)", +"lch(10 0 240 / 0.2)", "lch(10 0 240 / 0.2)", +"lch(10% 0% 240deg / 0.2)", "lch(10 0 240 / 0.2)", +"lch(10 0 240 / 1)", "lch(10 0 240)", +"lch(10% 0% 240deg / 1)", "lch(10 0 240)", +"lch(110 0 240)", "lch(110 0 240)", +"lch(110% 0% 240deg)", "lch(110 0 240)", +"lch(110 0 240 / 0)", "lch(110 0 240 / 0)", +"lch(110% 0% 240deg / 0)", "lch(110 0 240 / 0)", +"lch(110 0 240 / 0.2)", "lch(110 0 240 / 0.2)", +"lch(110% 0% 240deg / 0.2)", "lch(110 0 240 / 0.2)", +"lch(110 0 240 / 1)", "lch(110 0 240)", +"lch(110% 0% 240deg / 1)", "lch(110 0 240)", +"lch(-10 0 240)", "lch(-10 0 240)", +"lch(-10% 0% 240deg)", "lch(-10 0 240)", +"lch(-10 0 240 / 0)", "lch(-10 0 240 / 0)", +"lch(-10% 0% 240deg / 0)", "lch(-10 0 240 / 0)", +"lch(-10 0 240 / 0.2)", "lch(-10 0 240 / 0.2)", +"lch(-10% 0% 240deg / 0.2)", "lch(-10 0 240 / 0.2)", +"lch(-10 0 240 / 1)", "lch(-10 0 240)", +"lch(-10% 0% 240deg / 1)", "lch(-10 0 240)", +"lch(0 10 240)", "lch(0 10 240)", +"lch(0% 10% 240deg)", "lch(0 15 240)", +"lch(0 10 240 / 0)", "lch(0 10 240 / 0)", +"lch(0% 10% 240deg / 0)", "lch(0 15 240 / 0)", +"lch(0 10 240 / 0.2)", "lch(0 10 240 / 0.2)", +"lch(0% 10% 240deg / 0.2)", "lch(0 15 240 / 0.2)", +"lch(0 10 240 / 1)", "lch(0 10 240)", +"lch(0% 10% 240deg / 1)", "lch(0 15 240)", +"lch(10 10 240)", "lch(10 10 240)", +"lch(10% 10% 240deg)", "lch(10 15 240)", +"lch(10 10 240 / 0)", "lch(10 10 240 / 0)", +"lch(10% 10% 240deg / 0)", "lch(10 15 240 / 0)", +"lch(10 10 240 / 0.2)", "lch(10 10 240 / 0.2)", +"lch(10% 10% 240deg / 0.2)", "lch(10 15 240 / 0.2)", +"lch(10 10 240 / 1)", "lch(10 10 240)", +"lch(10% 10% 240deg / 1)", "lch(10 15 240)", +"lch(110 10 240)", "lch(110 10 240)", +"lch(110% 10% 240deg)", "lch(110 15 240)", +"lch(110 10 240 / 0)", "lch(110 10 240 / 0)", +"lch(110% 10% 240deg / 0)", "lch(110 15 240 / 0)", +"lch(110 10 240 / 0.2)", "lch(110 10 240 / 0.2)", +"lch(110% 10% 240deg / 0.2)", "lch(110 15 240 / 0.2)", +"lch(110 10 240 / 1)", "lch(110 10 240)", +"lch(110% 10% 240deg / 1)", "lch(110 15 240)", +"lch(-10 10 240)", "lch(-10 10 240)", +"lch(-10% 10% 240deg)", "lch(-10 15 240)", +"lch(-10 10 240 / 0)", "lch(-10 10 240 / 0)", +"lch(-10% 10% 240deg / 0)", "lch(-10 15 240 / 0)", +"lch(-10 10 240 / 0.2)", "lch(-10 10 240 / 0.2)", +"lch(-10% 10% 240deg / 0.2)", "lch(-10 15 240 / 0.2)", +"lch(-10 10 240 / 1)", "lch(-10 10 240)", +"lch(-10% 10% 240deg / 1)", "lch(-10 15 240)", +"lch(0 110 240)", "lch(0 110 240)", +"lch(0% 110% 240deg)", "lch(0 165 240)", +"lch(0 110 240 / 0)", "lch(0 110 240 / 0)", +"lch(0% 110% 240deg / 0)", "lch(0 165 240 / 0)", +"lch(0 110 240 / 0.2)", "lch(0 110 240 / 0.2)", +"lch(0% 110% 240deg / 0.2)", "lch(0 165 240 / 0.2)", +"lch(0 110 240 / 1)", "lch(0 110 240)", +"lch(0% 110% 240deg / 1)", "lch(0 165 240)", +"lch(10 110 240)", "lch(10 110 240)", +"lch(10% 110% 240deg)", "lch(10 165 240)", +"lch(10 110 240 / 0)", "lch(10 110 240 / 0)", +"lch(10% 110% 240deg / 0)", "lch(10 165 240 / 0)", +"lch(10 110 240 / 0.2)", "lch(10 110 240 / 0.2)", +"lch(10% 110% 240deg / 0.2)", "lch(10 165 240 / 0.2)", +"lch(10 110 240 / 1)", "lch(10 110 240)", +"lch(10% 110% 240deg / 1)", "lch(10 165 240)", +"lch(110 110 240)", "lch(110 110 240)", +"lch(110% 110% 240deg)", "lch(110 165 240)", +"lch(110 110 240 / 0)", "lch(110 110 240 / 0)", +"lch(110% 110% 240deg / 0)", "lch(110 165 240 / 0)", +"lch(110 110 240 / 0.2)", "lch(110 110 240 / 0.2)", +"lch(110% 110% 240deg / 0.2)", "lch(110 165 240 / 0.2)", +"lch(110 110 240 / 1)", "lch(110 110 240)", +"lch(110% 110% 240deg / 1)", "lch(110 165 240)", +"lch(-10 110 240)", "lch(-10 110 240)", +"lch(-10% 110% 240deg)", "lch(-10 165 240)", +"lch(-10 110 240 / 0)", "lch(-10 110 240 / 0)", +"lch(-10% 110% 240deg / 0)", "lch(-10 165 240 / 0)", +"lch(-10 110 240 / 0.2)", "lch(-10 110 240 / 0.2)", +"lch(-10% 110% 240deg / 0.2)", "lch(-10 165 240 / 0.2)", +"lch(-10 110 240 / 1)", "lch(-10 110 240)", +"lch(-10% 110% 240deg / 1)", "lch(-10 165 240)", +"lch(0 -10 240)", "lch(0 -10 240)", +"lch(0% -10% 240deg)", "lch(0 -15 240)", +"lch(0 -10 240 / 0)", "lch(0 -10 240 / 0)", +"lch(0% -10% 240deg / 0)", "lch(0 -15 240 / 0)", +"lch(0 -10 240 / 0.2)", "lch(0 -10 240 / 0.2)", +"lch(0% -10% 240deg / 0.2)", "lch(0 -15 240 / 0.2)", +"lch(0 -10 240 / 1)", "lch(0 -10 240)", +"lch(0% -10% 240deg / 1)", "lch(0 -15 240)", +"lch(10 -10 240)", "lch(10 -10 240)", +"lch(10% -10% 240deg)", "lch(10 -15 240)", +"lch(10 -10 240 / 0)", "lch(10 -10 240 / 0)", +"lch(10% -10% 240deg / 0)", "lch(10 -15 240 / 0)", +"lch(10 -10 240 / 0.2)", "lch(10 -10 240 / 0.2)", +"lch(10% -10% 240deg / 0.2)", "lch(10 -15 240 / 0.2)", +"lch(10 -10 240 / 1)", "lch(10 -10 240)", +"lch(10% -10% 240deg / 1)", "lch(10 -15 240)", +"lch(110 -10 240)", "lch(110 -10 240)", +"lch(110% -10% 240deg)", "lch(110 -15 240)", +"lch(110 -10 240 / 0)", "lch(110 -10 240 / 0)", +"lch(110% -10% 240deg / 0)", "lch(110 -15 240 / 0)", +"lch(110 -10 240 / 0.2)", "lch(110 -10 240 / 0.2)", +"lch(110% -10% 240deg / 0.2)", "lch(110 -15 240 / 0.2)", +"lch(110 -10 240 / 1)", "lch(110 -10 240)", +"lch(110% -10% 240deg / 1)", "lch(110 -15 240)", +"lch(-10 -10 240)", "lch(-10 -10 240)", +"lch(-10% -10% 240deg)", "lch(-10 -15 240)", +"lch(-10 -10 240 / 0)", "lch(-10 -10 240 / 0)", +"lch(-10% -10% 240deg / 0)", "lch(-10 -15 240 / 0)", +"lch(-10 -10 240 / 0.2)", "lch(-10 -10 240 / 0.2)", +"lch(-10% -10% 240deg / 0.2)", "lch(-10 -15 240 / 0.2)", +"lch(-10 -10 240 / 1)", "lch(-10 -10 240)", +"lch(-10% -10% 240deg / 1)", "lch(-10 -15 240)", +"lch(0 0 270)", "lch(0 0 270)", +"lch(0% 0% 270deg)", "lch(0 0 270)", +"lch(0 0 270 / 0)", "lch(0 0 270 / 0)", +"lch(0% 0% 270deg / 0)", "lch(0 0 270 / 0)", +"lch(0 0 270 / 0.2)", "lch(0 0 270 / 0.2)", +"lch(0% 0% 270deg / 0.2)", "lch(0 0 270 / 0.2)", +"lch(0 0 270 / 1)", "lch(0 0 270)", +"lch(0% 0% 270deg / 1)", "lch(0 0 270)", +"lch(10 0 270)", "lch(10 0 270)", +"lch(10% 0% 270deg)", "lch(10 0 270)", +"lch(10 0 270 / 0)", "lch(10 0 270 / 0)", +"lch(10% 0% 270deg / 0)", "lch(10 0 270 / 0)", +"lch(10 0 270 / 0.2)", "lch(10 0 270 / 0.2)", +"lch(10% 0% 270deg / 0.2)", "lch(10 0 270 / 0.2)", +"lch(10 0 270 / 1)", "lch(10 0 270)", +"lch(10% 0% 270deg / 1)", "lch(10 0 270)", +"lch(110 0 270)", "lch(110 0 270)", +"lch(110% 0% 270deg)", "lch(110 0 270)", +"lch(110 0 270 / 0)", "lch(110 0 270 / 0)", +"lch(110% 0% 270deg / 0)", "lch(110 0 270 / 0)", +"lch(110 0 270 / 0.2)", "lch(110 0 270 / 0.2)", +"lch(110% 0% 270deg / 0.2)", "lch(110 0 270 / 0.2)", +"lch(110 0 270 / 1)", "lch(110 0 270)", +"lch(110% 0% 270deg / 1)", "lch(110 0 270)", +"lch(-10 0 270)", "lch(-10 0 270)", +"lch(-10% 0% 270deg)", "lch(-10 0 270)", +"lch(-10 0 270 / 0)", "lch(-10 0 270 / 0)", +"lch(-10% 0% 270deg / 0)", "lch(-10 0 270 / 0)", +"lch(-10 0 270 / 0.2)", "lch(-10 0 270 / 0.2)", +"lch(-10% 0% 270deg / 0.2)", "lch(-10 0 270 / 0.2)", +"lch(-10 0 270 / 1)", "lch(-10 0 270)", +"lch(-10% 0% 270deg / 1)", "lch(-10 0 270)", +"lch(0 10 270)", "lch(0 10 270)", +"lch(0% 10% 270deg)", "lch(0 15 270)", +"lch(0 10 270 / 0)", "lch(0 10 270 / 0)", +"lch(0% 10% 270deg / 0)", "lch(0 15 270 / 0)", +"lch(0 10 270 / 0.2)", "lch(0 10 270 / 0.2)", +"lch(0% 10% 270deg / 0.2)", "lch(0 15 270 / 0.2)", +"lch(0 10 270 / 1)", "lch(0 10 270)", +"lch(0% 10% 270deg / 1)", "lch(0 15 270)", +"lch(10 10 270)", "lch(10 10 270)", +"lch(10% 10% 270deg)", "lch(10 15 270)", +"lch(10 10 270 / 0)", "lch(10 10 270 / 0)", +"lch(10% 10% 270deg / 0)", "lch(10 15 270 / 0)", +"lch(10 10 270 / 0.2)", "lch(10 10 270 / 0.2)", +"lch(10% 10% 270deg / 0.2)", "lch(10 15 270 / 0.2)", +"lch(10 10 270 / 1)", "lch(10 10 270)", +"lch(10% 10% 270deg / 1)", "lch(10 15 270)", +"lch(110 10 270)", "lch(110 10 270)", +"lch(110% 10% 270deg)", "lch(110 15 270)", +"lch(110 10 270 / 0)", "lch(110 10 270 / 0)", +"lch(110% 10% 270deg / 0)", "lch(110 15 270 / 0)", +"lch(110 10 270 / 0.2)", "lch(110 10 270 / 0.2)", +"lch(110% 10% 270deg / 0.2)", "lch(110 15 270 / 0.2)", +"lch(110 10 270 / 1)", "lch(110 10 270)", +"lch(110% 10% 270deg / 1)", "lch(110 15 270)", +"lch(-10 10 270)", "lch(-10 10 270)", +"lch(-10% 10% 270deg)", "lch(-10 15 270)", +"lch(-10 10 270 / 0)", "lch(-10 10 270 / 0)", +"lch(-10% 10% 270deg / 0)", "lch(-10 15 270 / 0)", +"lch(-10 10 270 / 0.2)", "lch(-10 10 270 / 0.2)", +"lch(-10% 10% 270deg / 0.2)", "lch(-10 15 270 / 0.2)", +"lch(-10 10 270 / 1)", "lch(-10 10 270)", +"lch(-10% 10% 270deg / 1)", "lch(-10 15 270)", +"lch(0 110 270)", "lch(0 110 270)", +"lch(0% 110% 270deg)", "lch(0 165 270)", +"lch(0 110 270 / 0)", "lch(0 110 270 / 0)", +"lch(0% 110% 270deg / 0)", "lch(0 165 270 / 0)", +"lch(0 110 270 / 0.2)", "lch(0 110 270 / 0.2)", +"lch(0% 110% 270deg / 0.2)", "lch(0 165 270 / 0.2)", +"lch(0 110 270 / 1)", "lch(0 110 270)", +"lch(0% 110% 270deg / 1)", "lch(0 165 270)", +"lch(10 110 270)", "lch(10 110 270)", +"lch(10% 110% 270deg)", "lch(10 165 270)", +"lch(10 110 270 / 0)", "lch(10 110 270 / 0)", +"lch(10% 110% 270deg / 0)", "lch(10 165 270 / 0)", +"lch(10 110 270 / 0.2)", "lch(10 110 270 / 0.2)", +"lch(10% 110% 270deg / 0.2)", "lch(10 165 270 / 0.2)", +"lch(10 110 270 / 1)", "lch(10 110 270)", +"lch(10% 110% 270deg / 1)", "lch(10 165 270)", +"lch(110 110 270)", "lch(110 110 270)", +"lch(110% 110% 270deg)", "lch(110 165 270)", +"lch(110 110 270 / 0)", "lch(110 110 270 / 0)", +"lch(110% 110% 270deg / 0)", "lch(110 165 270 / 0)", +"lch(110 110 270 / 0.2)", "lch(110 110 270 / 0.2)", +"lch(110% 110% 270deg / 0.2)", "lch(110 165 270 / 0.2)", +"lch(110 110 270 / 1)", "lch(110 110 270)", +"lch(110% 110% 270deg / 1)", "lch(110 165 270)", +"lch(-10 110 270)", "lch(-10 110 270)", +"lch(-10% 110% 270deg)", "lch(-10 165 270)", +"lch(-10 110 270 / 0)", "lch(-10 110 270 / 0)", +"lch(-10% 110% 270deg / 0)", "lch(-10 165 270 / 0)", +"lch(-10 110 270 / 0.2)", "lch(-10 110 270 / 0.2)", +"lch(-10% 110% 270deg / 0.2)", "lch(-10 165 270 / 0.2)", +"lch(-10 110 270 / 1)", "lch(-10 110 270)", +"lch(-10% 110% 270deg / 1)", "lch(-10 165 270)", +"lch(0 -10 270)", "lch(0 -10 270)", +"lch(0% -10% 270deg)", "lch(0 -15 270)", +"lch(0 -10 270 / 0)", "lch(0 -10 270 / 0)", +"lch(0% -10% 270deg / 0)", "lch(0 -15 270 / 0)", +"lch(0 -10 270 / 0.2)", "lch(0 -10 270 / 0.2)", +"lch(0% -10% 270deg / 0.2)", "lch(0 -15 270 / 0.2)", +"lch(0 -10 270 / 1)", "lch(0 -10 270)", +"lch(0% -10% 270deg / 1)", "lch(0 -15 270)", +"lch(10 -10 270)", "lch(10 -10 270)", +"lch(10% -10% 270deg)", "lch(10 -15 270)", +"lch(10 -10 270 / 0)", "lch(10 -10 270 / 0)", +"lch(10% -10% 270deg / 0)", "lch(10 -15 270 / 0)", +"lch(10 -10 270 / 0.2)", "lch(10 -10 270 / 0.2)", +"lch(10% -10% 270deg / 0.2)", "lch(10 -15 270 / 0.2)", +"lch(10 -10 270 / 1)", "lch(10 -10 270)", +"lch(10% -10% 270deg / 1)", "lch(10 -15 270)", +"lch(110 -10 270)", "lch(110 -10 270)", +"lch(110% -10% 270deg)", "lch(110 -15 270)", +"lch(110 -10 270 / 0)", "lch(110 -10 270 / 0)", +"lch(110% -10% 270deg / 0)", "lch(110 -15 270 / 0)", +"lch(110 -10 270 / 0.2)", "lch(110 -10 270 / 0.2)", +"lch(110% -10% 270deg / 0.2)", "lch(110 -15 270 / 0.2)", +"lch(110 -10 270 / 1)", "lch(110 -10 270)", +"lch(110% -10% 270deg / 1)", "lch(110 -15 270)", +"lch(-10 -10 270)", "lch(-10 -10 270)", +"lch(-10% -10% 270deg)", "lch(-10 -15 270)", +"lch(-10 -10 270 / 0)", "lch(-10 -10 270 / 0)", +"lch(-10% -10% 270deg / 0)", "lch(-10 -15 270 / 0)", +"lch(-10 -10 270 / 0.2)", "lch(-10 -10 270 / 0.2)", +"lch(-10% -10% 270deg / 0.2)", "lch(-10 -15 270 / 0.2)", +"lch(-10 -10 270 / 1)", "lch(-10 -10 270)", +"lch(-10% -10% 270deg / 1)", "lch(-10 -15 270)", +"lch(0 0 300)", "lch(0 0 300)", +"lch(0% 0% 300deg)", "lch(0 0 300)", +"lch(0 0 300 / 0)", "lch(0 0 300 / 0)", +"lch(0% 0% 300deg / 0)", "lch(0 0 300 / 0)", +"lch(0 0 300 / 0.2)", "lch(0 0 300 / 0.2)", +"lch(0% 0% 300deg / 0.2)", "lch(0 0 300 / 0.2)", +"lch(0 0 300 / 1)", "lch(0 0 300)", +"lch(0% 0% 300deg / 1)", "lch(0 0 300)", +"lch(10 0 300)", "lch(10 0 300)", +"lch(10% 0% 300deg)", "lch(10 0 300)", +"lch(10 0 300 / 0)", "lch(10 0 300 / 0)", +"lch(10% 0% 300deg / 0)", "lch(10 0 300 / 0)", +"lch(10 0 300 / 0.2)", "lch(10 0 300 / 0.2)", +"lch(10% 0% 300deg / 0.2)", "lch(10 0 300 / 0.2)", +"lch(10 0 300 / 1)", "lch(10 0 300)", +"lch(10% 0% 300deg / 1)", "lch(10 0 300)", +"lch(110 0 300)", "lch(110 0 300)", +"lch(110% 0% 300deg)", "lch(110 0 300)", +"lch(110 0 300 / 0)", "lch(110 0 300 / 0)", +"lch(110% 0% 300deg / 0)", "lch(110 0 300 / 0)", +"lch(110 0 300 / 0.2)", "lch(110 0 300 / 0.2)", +"lch(110% 0% 300deg / 0.2)", "lch(110 0 300 / 0.2)", +"lch(110 0 300 / 1)", "lch(110 0 300)", +"lch(110% 0% 300deg / 1)", "lch(110 0 300)", +"lch(-10 0 300)", "lch(-10 0 300)", +"lch(-10% 0% 300deg)", "lch(-10 0 300)", +"lch(-10 0 300 / 0)", "lch(-10 0 300 / 0)", +"lch(-10% 0% 300deg / 0)", "lch(-10 0 300 / 0)", +"lch(-10 0 300 / 0.2)", "lch(-10 0 300 / 0.2)", +"lch(-10% 0% 300deg / 0.2)", "lch(-10 0 300 / 0.2)", +"lch(-10 0 300 / 1)", "lch(-10 0 300)", +"lch(-10% 0% 300deg / 1)", "lch(-10 0 300)", +"lch(0 10 300)", "lch(0 10 300)", +"lch(0% 10% 300deg)", "lch(0 15 300)", +"lch(0 10 300 / 0)", "lch(0 10 300 / 0)", +"lch(0% 10% 300deg / 0)", "lch(0 15 300 / 0)", +"lch(0 10 300 / 0.2)", "lch(0 10 300 / 0.2)", +"lch(0% 10% 300deg / 0.2)", "lch(0 15 300 / 0.2)", +"lch(0 10 300 / 1)", "lch(0 10 300)", +"lch(0% 10% 300deg / 1)", "lch(0 15 300)", +"lch(10 10 300)", "lch(10 10 300)", +"lch(10% 10% 300deg)", "lch(10 15 300)", +"lch(10 10 300 / 0)", "lch(10 10 300 / 0)", +"lch(10% 10% 300deg / 0)", "lch(10 15 300 / 0)", +"lch(10 10 300 / 0.2)", "lch(10 10 300 / 0.2)", +"lch(10% 10% 300deg / 0.2)", "lch(10 15 300 / 0.2)", +"lch(10 10 300 / 1)", "lch(10 10 300)", +"lch(10% 10% 300deg / 1)", "lch(10 15 300)", +"lch(110 10 300)", "lch(110 10 300)", +"lch(110% 10% 300deg)", "lch(110 15 300)", +"lch(110 10 300 / 0)", "lch(110 10 300 / 0)", +"lch(110% 10% 300deg / 0)", "lch(110 15 300 / 0)", +"lch(110 10 300 / 0.2)", "lch(110 10 300 / 0.2)", +"lch(110% 10% 300deg / 0.2)", "lch(110 15 300 / 0.2)", +"lch(110 10 300 / 1)", "lch(110 10 300)", +"lch(110% 10% 300deg / 1)", "lch(110 15 300)", +"lch(-10 10 300)", "lch(-10 10 300)", +"lch(-10% 10% 300deg)", "lch(-10 15 300)", +"lch(-10 10 300 / 0)", "lch(-10 10 300 / 0)", +"lch(-10% 10% 300deg / 0)", "lch(-10 15 300 / 0)", +"lch(-10 10 300 / 0.2)", "lch(-10 10 300 / 0.2)", +"lch(-10% 10% 300deg / 0.2)", "lch(-10 15 300 / 0.2)", +"lch(-10 10 300 / 1)", "lch(-10 10 300)", +"lch(-10% 10% 300deg / 1)", "lch(-10 15 300)", +"lch(0 110 300)", "lch(0 110 300)", +"lch(0% 110% 300deg)", "lch(0 165 300)", +"lch(0 110 300 / 0)", "lch(0 110 300 / 0)", +"lch(0% 110% 300deg / 0)", "lch(0 165 300 / 0)", +"lch(0 110 300 / 0.2)", "lch(0 110 300 / 0.2)", +"lch(0% 110% 300deg / 0.2)", "lch(0 165 300 / 0.2)", +"lch(0 110 300 / 1)", "lch(0 110 300)", +"lch(0% 110% 300deg / 1)", "lch(0 165 300)", +"lch(10 110 300)", "lch(10 110 300)", +"lch(10% 110% 300deg)", "lch(10 165 300)", +"lch(10 110 300 / 0)", "lch(10 110 300 / 0)", +"lch(10% 110% 300deg / 0)", "lch(10 165 300 / 0)", +"lch(10 110 300 / 0.2)", "lch(10 110 300 / 0.2)", +"lch(10% 110% 300deg / 0.2)", "lch(10 165 300 / 0.2)", +"lch(10 110 300 / 1)", "lch(10 110 300)", +"lch(10% 110% 300deg / 1)", "lch(10 165 300)", +"lch(110 110 300)", "lch(110 110 300)", +"lch(110% 110% 300deg)", "lch(110 165 300)", +"lch(110 110 300 / 0)", "lch(110 110 300 / 0)", +"lch(110% 110% 300deg / 0)", "lch(110 165 300 / 0)", +"lch(110 110 300 / 0.2)", "lch(110 110 300 / 0.2)", +"lch(110% 110% 300deg / 0.2)", "lch(110 165 300 / 0.2)", +"lch(110 110 300 / 1)", "lch(110 110 300)", +"lch(110% 110% 300deg / 1)", "lch(110 165 300)", +"lch(-10 110 300)", "lch(-10 110 300)", +"lch(-10% 110% 300deg)", "lch(-10 165 300)", +"lch(-10 110 300 / 0)", "lch(-10 110 300 / 0)", +"lch(-10% 110% 300deg / 0)", "lch(-10 165 300 / 0)", +"lch(-10 110 300 / 0.2)", "lch(-10 110 300 / 0.2)", +"lch(-10% 110% 300deg / 0.2)", "lch(-10 165 300 / 0.2)", +"lch(-10 110 300 / 1)", "lch(-10 110 300)", +"lch(-10% 110% 300deg / 1)", "lch(-10 165 300)", +"lch(0 -10 300)", "lch(0 -10 300)", +"lch(0% -10% 300deg)", "lch(0 -15 300)", +"lch(0 -10 300 / 0)", "lch(0 -10 300 / 0)", +"lch(0% -10% 300deg / 0)", "lch(0 -15 300 / 0)", +"lch(0 -10 300 / 0.2)", "lch(0 -10 300 / 0.2)", +"lch(0% -10% 300deg / 0.2)", "lch(0 -15 300 / 0.2)", +"lch(0 -10 300 / 1)", "lch(0 -10 300)", +"lch(0% -10% 300deg / 1)", "lch(0 -15 300)", +"lch(10 -10 300)", "lch(10 -10 300)", +"lch(10% -10% 300deg)", "lch(10 -15 300)", +"lch(10 -10 300 / 0)", "lch(10 -10 300 / 0)", +"lch(10% -10% 300deg / 0)", "lch(10 -15 300 / 0)", +"lch(10 -10 300 / 0.2)", "lch(10 -10 300 / 0.2)", +"lch(10% -10% 300deg / 0.2)", "lch(10 -15 300 / 0.2)", +"lch(10 -10 300 / 1)", "lch(10 -10 300)", +"lch(10% -10% 300deg / 1)", "lch(10 -15 300)", +"lch(110 -10 300)", "lch(110 -10 300)", +"lch(110% -10% 300deg)", "lch(110 -15 300)", +"lch(110 -10 300 / 0)", "lch(110 -10 300 / 0)", +"lch(110% -10% 300deg / 0)", "lch(110 -15 300 / 0)", +"lch(110 -10 300 / 0.2)", "lch(110 -10 300 / 0.2)", +"lch(110% -10% 300deg / 0.2)", "lch(110 -15 300 / 0.2)", +"lch(110 -10 300 / 1)", "lch(110 -10 300)", +"lch(110% -10% 300deg / 1)", "lch(110 -15 300)", +"lch(-10 -10 300)", "lch(-10 -10 300)", +"lch(-10% -10% 300deg)", "lch(-10 -15 300)", +"lch(-10 -10 300 / 0)", "lch(-10 -10 300 / 0)", +"lch(-10% -10% 300deg / 0)", "lch(-10 -15 300 / 0)", +"lch(-10 -10 300 / 0.2)", "lch(-10 -10 300 / 0.2)", +"lch(-10% -10% 300deg / 0.2)", "lch(-10 -15 300 / 0.2)", +"lch(-10 -10 300 / 1)", "lch(-10 -10 300)", +"lch(-10% -10% 300deg / 1)", "lch(-10 -15 300)", +"lch(0 0 330)", "lch(0 0 330)", +"lch(0% 0% 330deg)", "lch(0 0 330)", +"lch(0 0 330 / 0)", "lch(0 0 330 / 0)", +"lch(0% 0% 330deg / 0)", "lch(0 0 330 / 0)", +"lch(0 0 330 / 0.2)", "lch(0 0 330 / 0.2)", +"lch(0% 0% 330deg / 0.2)", "lch(0 0 330 / 0.2)", +"lch(0 0 330 / 1)", "lch(0 0 330)", +"lch(0% 0% 330deg / 1)", "lch(0 0 330)", +"lch(10 0 330)", "lch(10 0 330)", +"lch(10% 0% 330deg)", "lch(10 0 330)", +"lch(10 0 330 / 0)", "lch(10 0 330 / 0)", +"lch(10% 0% 330deg / 0)", "lch(10 0 330 / 0)", +"lch(10 0 330 / 0.2)", "lch(10 0 330 / 0.2)", +"lch(10% 0% 330deg / 0.2)", "lch(10 0 330 / 0.2)", +"lch(10 0 330 / 1)", "lch(10 0 330)", +"lch(10% 0% 330deg / 1)", "lch(10 0 330)", +"lch(110 0 330)", "lch(110 0 330)", +"lch(110% 0% 330deg)", "lch(110 0 330)", +"lch(110 0 330 / 0)", "lch(110 0 330 / 0)", +"lch(110% 0% 330deg / 0)", "lch(110 0 330 / 0)", +"lch(110 0 330 / 0.2)", "lch(110 0 330 / 0.2)", +"lch(110% 0% 330deg / 0.2)", "lch(110 0 330 / 0.2)", +"lch(110 0 330 / 1)", "lch(110 0 330)", +"lch(110% 0% 330deg / 1)", "lch(110 0 330)", +"lch(-10 0 330)", "lch(-10 0 330)", +"lch(-10% 0% 330deg)", "lch(-10 0 330)", +"lch(-10 0 330 / 0)", "lch(-10 0 330 / 0)", +"lch(-10% 0% 330deg / 0)", "lch(-10 0 330 / 0)", +"lch(-10 0 330 / 0.2)", "lch(-10 0 330 / 0.2)", +"lch(-10% 0% 330deg / 0.2)", "lch(-10 0 330 / 0.2)", +"lch(-10 0 330 / 1)", "lch(-10 0 330)", +"lch(-10% 0% 330deg / 1)", "lch(-10 0 330)", +"lch(0 10 330)", "lch(0 10 330)", +"lch(0% 10% 330deg)", "lch(0 15 330)", +"lch(0 10 330 / 0)", "lch(0 10 330 / 0)", +"lch(0% 10% 330deg / 0)", "lch(0 15 330 / 0)", +"lch(0 10 330 / 0.2)", "lch(0 10 330 / 0.2)", +"lch(0% 10% 330deg / 0.2)", "lch(0 15 330 / 0.2)", +"lch(0 10 330 / 1)", "lch(0 10 330)", +"lch(0% 10% 330deg / 1)", "lch(0 15 330)", +"lch(10 10 330)", "lch(10 10 330)", +"lch(10% 10% 330deg)", "lch(10 15 330)", +"lch(10 10 330 / 0)", "lch(10 10 330 / 0)", +"lch(10% 10% 330deg / 0)", "lch(10 15 330 / 0)", +"lch(10 10 330 / 0.2)", "lch(10 10 330 / 0.2)", +"lch(10% 10% 330deg / 0.2)", "lch(10 15 330 / 0.2)", +"lch(10 10 330 / 1)", "lch(10 10 330)", +"lch(10% 10% 330deg / 1)", "lch(10 15 330)", +"lch(110 10 330)", "lch(110 10 330)", +"lch(110% 10% 330deg)", "lch(110 15 330)", +"lch(110 10 330 / 0)", "lch(110 10 330 / 0)", +"lch(110% 10% 330deg / 0)", "lch(110 15 330 / 0)", +"lch(110 10 330 / 0.2)", "lch(110 10 330 / 0.2)", +"lch(110% 10% 330deg / 0.2)", "lch(110 15 330 / 0.2)", +"lch(110 10 330 / 1)", "lch(110 10 330)", +"lch(110% 10% 330deg / 1)", "lch(110 15 330)", +"lch(-10 10 330)", "lch(-10 10 330)", +"lch(-10% 10% 330deg)", "lch(-10 15 330)", +"lch(-10 10 330 / 0)", "lch(-10 10 330 / 0)", +"lch(-10% 10% 330deg / 0)", "lch(-10 15 330 / 0)", +"lch(-10 10 330 / 0.2)", "lch(-10 10 330 / 0.2)", +"lch(-10% 10% 330deg / 0.2)", "lch(-10 15 330 / 0.2)", +"lch(-10 10 330 / 1)", "lch(-10 10 330)", +"lch(-10% 10% 330deg / 1)", "lch(-10 15 330)", +"lch(0 110 330)", "lch(0 110 330)", +"lch(0% 110% 330deg)", "lch(0 165 330)", +"lch(0 110 330 / 0)", "lch(0 110 330 / 0)", +"lch(0% 110% 330deg / 0)", "lch(0 165 330 / 0)", +"lch(0 110 330 / 0.2)", "lch(0 110 330 / 0.2)", +"lch(0% 110% 330deg / 0.2)", "lch(0 165 330 / 0.2)", +"lch(0 110 330 / 1)", "lch(0 110 330)", +"lch(0% 110% 330deg / 1)", "lch(0 165 330)", +"lch(10 110 330)", "lch(10 110 330)", +"lch(10% 110% 330deg)", "lch(10 165 330)", +"lch(10 110 330 / 0)", "lch(10 110 330 / 0)", +"lch(10% 110% 330deg / 0)", "lch(10 165 330 / 0)", +"lch(10 110 330 / 0.2)", "lch(10 110 330 / 0.2)", +"lch(10% 110% 330deg / 0.2)", "lch(10 165 330 / 0.2)", +"lch(10 110 330 / 1)", "lch(10 110 330)", +"lch(10% 110% 330deg / 1)", "lch(10 165 330)", +"lch(110 110 330)", "lch(110 110 330)", +"lch(110% 110% 330deg)", "lch(110 165 330)", +"lch(110 110 330 / 0)", "lch(110 110 330 / 0)", +"lch(110% 110% 330deg / 0)", "lch(110 165 330 / 0)", +"lch(110 110 330 / 0.2)", "lch(110 110 330 / 0.2)", +"lch(110% 110% 330deg / 0.2)", "lch(110 165 330 / 0.2)", +"lch(110 110 330 / 1)", "lch(110 110 330)", +"lch(110% 110% 330deg / 1)", "lch(110 165 330)", +"lch(-10 110 330)", "lch(-10 110 330)", +"lch(-10% 110% 330deg)", "lch(-10 165 330)", +"lch(-10 110 330 / 0)", "lch(-10 110 330 / 0)", +"lch(-10% 110% 330deg / 0)", "lch(-10 165 330 / 0)", +"lch(-10 110 330 / 0.2)", "lch(-10 110 330 / 0.2)", +"lch(-10% 110% 330deg / 0.2)", "lch(-10 165 330 / 0.2)", +"lch(-10 110 330 / 1)", "lch(-10 110 330)", +"lch(-10% 110% 330deg / 1)", "lch(-10 165 330)", +"lch(0 -10 330)", "lch(0 -10 330)", +"lch(0% -10% 330deg)", "lch(0 -15 330)", +"lch(0 -10 330 / 0)", "lch(0 -10 330 / 0)", +"lch(0% -10% 330deg / 0)", "lch(0 -15 330 / 0)", +"lch(0 -10 330 / 0.2)", "lch(0 -10 330 / 0.2)", +"lch(0% -10% 330deg / 0.2)", "lch(0 -15 330 / 0.2)", +"lch(0 -10 330 / 1)", "lch(0 -10 330)", +"lch(0% -10% 330deg / 1)", "lch(0 -15 330)", +"lch(10 -10 330)", "lch(10 -10 330)", +"lch(10% -10% 330deg)", "lch(10 -15 330)", +"lch(10 -10 330 / 0)", "lch(10 -10 330 / 0)", +"lch(10% -10% 330deg / 0)", "lch(10 -15 330 / 0)", +"lch(10 -10 330 / 0.2)", "lch(10 -10 330 / 0.2)", +"lch(10% -10% 330deg / 0.2)", "lch(10 -15 330 / 0.2)", +"lch(10 -10 330 / 1)", "lch(10 -10 330)", +"lch(10% -10% 330deg / 1)", "lch(10 -15 330)", +"lch(110 -10 330)", "lch(110 -10 330)", +"lch(110% -10% 330deg)", "lch(110 -15 330)", +"lch(110 -10 330 / 0)", "lch(110 -10 330 / 0)", +"lch(110% -10% 330deg / 0)", "lch(110 -15 330 / 0)", +"lch(110 -10 330 / 0.2)", "lch(110 -10 330 / 0.2)", +"lch(110% -10% 330deg / 0.2)", "lch(110 -15 330 / 0.2)", +"lch(110 -10 330 / 1)", "lch(110 -10 330)", +"lch(110% -10% 330deg / 1)", "lch(110 -15 330)", +"lch(-10 -10 330)", "lch(-10 -10 330)", +"lch(-10% -10% 330deg)", "lch(-10 -15 330)", +"lch(-10 -10 330 / 0)", "lch(-10 -10 330 / 0)", +"lch(-10% -10% 330deg / 0)", "lch(-10 -15 330 / 0)", +"lch(-10 -10 330 / 0.2)", "lch(-10 -10 330 / 0.2)", +"lch(-10% -10% 330deg / 0.2)", "lch(-10 -15 330 / 0.2)", +"lch(-10 -10 330 / 1)", "lch(-10 -10 330)", +"lch(-10% -10% 330deg / 1)", "lch(-10 -15 330)", +"lch(0 0 360)", "lch(0 0 0)", +"lch(0% 0% 360deg)", "lch(0 0 0)", +"lch(0 0 360 / 0)", "lch(0 0 0 / 0)", +"lch(0% 0% 360deg / 0)", "lch(0 0 0 / 0)", +"lch(0 0 360 / 0.2)", "lch(0 0 0 / 0.2)", +"lch(0% 0% 360deg / 0.2)", "lch(0 0 0 / 0.2)", +"lch(0 0 360 / 1)", "lch(0 0 0)", +"lch(0% 0% 360deg / 1)", "lch(0 0 0)", +"lch(10 0 360)", "lch(10 0 0)", +"lch(10% 0% 360deg)", "lch(10 0 0)", +"lch(10 0 360 / 0)", "lch(10 0 0 / 0)", +"lch(10% 0% 360deg / 0)", "lch(10 0 0 / 0)", +"lch(10 0 360 / 0.2)", "lch(10 0 0 / 0.2)", +"lch(10% 0% 360deg / 0.2)", "lch(10 0 0 / 0.2)", +"lch(10 0 360 / 1)", "lch(10 0 0)", +"lch(10% 0% 360deg / 1)", "lch(10 0 0)", +"lch(110 0 360)", "lch(110 0 0)", +"lch(110% 0% 360deg)", "lch(110 0 0)", +"lch(110 0 360 / 0)", "lch(110 0 0 / 0)", +"lch(110% 0% 360deg / 0)", "lch(110 0 0 / 0)", +"lch(110 0 360 / 0.2)", "lch(110 0 0 / 0.2)", +"lch(110% 0% 360deg / 0.2)", "lch(110 0 0 / 0.2)", +"lch(110 0 360 / 1)", "lch(110 0 0)", +"lch(110% 0% 360deg / 1)", "lch(110 0 0)", +"lch(-10 0 360)", "lch(-10 0 0)", +"lch(-10% 0% 360deg)", "lch(-10 0 0)", +"lch(-10 0 360 / 0)", "lch(-10 0 0 / 0)", +"lch(-10% 0% 360deg / 0)", "lch(-10 0 0 / 0)", +"lch(-10 0 360 / 0.2)", "lch(-10 0 0 / 0.2)", +"lch(-10% 0% 360deg / 0.2)", "lch(-10 0 0 / 0.2)", +"lch(-10 0 360 / 1)", "lch(-10 0 0)", +"lch(-10% 0% 360deg / 1)", "lch(-10 0 0)", +"lch(0 10 360)", "lch(0 10 0)", +"lch(0% 10% 360deg)", "lch(0 15 0)", +"lch(0 10 360 / 0)", "lch(0 10 0 / 0)", +"lch(0% 10% 360deg / 0)", "lch(0 15 0 / 0)", +"lch(0 10 360 / 0.2)", "lch(0 10 0 / 0.2)", +"lch(0% 10% 360deg / 0.2)", "lch(0 15 0 / 0.2)", +"lch(0 10 360 / 1)", "lch(0 10 0)", +"lch(0% 10% 360deg / 1)", "lch(0 15 0)", +"lch(10 10 360)", "lch(10 10 0)", +"lch(10% 10% 360deg)", "lch(10 15 0)", +"lch(10 10 360 / 0)", "lch(10 10 0 / 0)", +"lch(10% 10% 360deg / 0)", "lch(10 15 0 / 0)", +"lch(10 10 360 / 0.2)", "lch(10 10 0 / 0.2)", +"lch(10% 10% 360deg / 0.2)", "lch(10 15 0 / 0.2)", +"lch(10 10 360 / 1)", "lch(10 10 0)", +"lch(10% 10% 360deg / 1)", "lch(10 15 0)", +"lch(110 10 360)", "lch(110 10 0)", +"lch(110% 10% 360deg)", "lch(110 15 0)", +"lch(110 10 360 / 0)", "lch(110 10 0 / 0)", +"lch(110% 10% 360deg / 0)", "lch(110 15 0 / 0)", +"lch(110 10 360 / 0.2)", "lch(110 10 0 / 0.2)", +"lch(110% 10% 360deg / 0.2)", "lch(110 15 0 / 0.2)", +"lch(110 10 360 / 1)", "lch(110 10 0)", +"lch(110% 10% 360deg / 1)", "lch(110 15 0)", +"lch(-10 10 360)", "lch(-10 10 0)", +"lch(-10% 10% 360deg)", "lch(-10 15 0)", +"lch(-10 10 360 / 0)", "lch(-10 10 0 / 0)", +"lch(-10% 10% 360deg / 0)", "lch(-10 15 0 / 0)", +"lch(-10 10 360 / 0.2)", "lch(-10 10 0 / 0.2)", +"lch(-10% 10% 360deg / 0.2)", "lch(-10 15 0 / 0.2)", +"lch(-10 10 360 / 1)", "lch(-10 10 0)", +"lch(-10% 10% 360deg / 1)", "lch(-10 15 0)", +"lch(0 110 360)", "lch(0 110 0)", +"lch(0% 110% 360deg)", "lch(0 165 0)", +"lch(0 110 360 / 0)", "lch(0 110 0 / 0)", +"lch(0% 110% 360deg / 0)", "lch(0 165 0 / 0)", +"lch(0 110 360 / 0.2)", "lch(0 110 0 / 0.2)", +"lch(0% 110% 360deg / 0.2)", "lch(0 165 0 / 0.2)", +"lch(0 110 360 / 1)", "lch(0 110 0)", +"lch(0% 110% 360deg / 1)", "lch(0 165 0)", +"lch(10 110 360)", "lch(10 110 0)", +"lch(10% 110% 360deg)", "lch(10 165 0)", +"lch(10 110 360 / 0)", "lch(10 110 0 / 0)", +"lch(10% 110% 360deg / 0)", "lch(10 165 0 / 0)", +"lch(10 110 360 / 0.2)", "lch(10 110 0 / 0.2)", +"lch(10% 110% 360deg / 0.2)", "lch(10 165 0 / 0.2)", +"lch(10 110 360 / 1)", "lch(10 110 0)", +"lch(10% 110% 360deg / 1)", "lch(10 165 0)", +"lch(110 110 360)", "lch(110 110 0)", +"lch(110% 110% 360deg)", "lch(110 165 0)", +"lch(110 110 360 / 0)", "lch(110 110 0 / 0)", +"lch(110% 110% 360deg / 0)", "lch(110 165 0 / 0)", +"lch(110 110 360 / 0.2)", "lch(110 110 0 / 0.2)", +"lch(110% 110% 360deg / 0.2)", "lch(110 165 0 / 0.2)", +"lch(110 110 360 / 1)", "lch(110 110 0)", +"lch(110% 110% 360deg / 1)", "lch(110 165 0)", +"lch(-10 110 360)", "lch(-10 110 0)", +"lch(-10% 110% 360deg)", "lch(-10 165 0)", +"lch(-10 110 360 / 0)", "lch(-10 110 0 / 0)", +"lch(-10% 110% 360deg / 0)", "lch(-10 165 0 / 0)", +"lch(-10 110 360 / 0.2)", "lch(-10 110 0 / 0.2)", +"lch(-10% 110% 360deg / 0.2)", "lch(-10 165 0 / 0.2)", +"lch(-10 110 360 / 1)", "lch(-10 110 0)", +"lch(-10% 110% 360deg / 1)", "lch(-10 165 0)", +"lch(0 -10 360)", "lch(0 -10 0)", +"lch(0% -10% 360deg)", "lch(0 -15 0)", +"lch(0 -10 360 / 0)", "lch(0 -10 0 / 0)", +"lch(0% -10% 360deg / 0)", "lch(0 -15 0 / 0)", +"lch(0 -10 360 / 0.2)", "lch(0 -10 0 / 0.2)", +"lch(0% -10% 360deg / 0.2)", "lch(0 -15 0 / 0.2)", +"lch(0 -10 360 / 1)", "lch(0 -10 0)", +"lch(0% -10% 360deg / 1)", "lch(0 -15 0)", +"lch(10 -10 360)", "lch(10 -10 0)", +"lch(10% -10% 360deg)", "lch(10 -15 0)", +"lch(10 -10 360 / 0)", "lch(10 -10 0 / 0)", +"lch(10% -10% 360deg / 0)", "lch(10 -15 0 / 0)", +"lch(10 -10 360 / 0.2)", "lch(10 -10 0 / 0.2)", +"lch(10% -10% 360deg / 0.2)", "lch(10 -15 0 / 0.2)", +"lch(10 -10 360 / 1)", "lch(10 -10 0)", +"lch(10% -10% 360deg / 1)", "lch(10 -15 0)", +"lch(110 -10 360)", "lch(110 -10 0)", +"lch(110% -10% 360deg)", "lch(110 -15 0)", +"lch(110 -10 360 / 0)", "lch(110 -10 0 / 0)", +"lch(110% -10% 360deg / 0)", "lch(110 -15 0 / 0)", +"lch(110 -10 360 / 0.2)", "lch(110 -10 0 / 0.2)", +"lch(110% -10% 360deg / 0.2)", "lch(110 -15 0 / 0.2)", +"lch(110 -10 360 / 1)", "lch(110 -10 0)", +"lch(110% -10% 360deg / 1)", "lch(110 -15 0)", +"lch(-10 -10 360)", "lch(-10 -10 0)", +"lch(-10% -10% 360deg)", "lch(-10 -15 0)", +"lch(-10 -10 360 / 0)", "lch(-10 -10 0 / 0)", +"lch(-10% -10% 360deg / 0)", "lch(-10 -15 0 / 0)", +"lch(-10 -10 360 / 0.2)", "lch(-10 -10 0 / 0.2)", +"lch(-10% -10% 360deg / 0.2)", "lch(-10 -15 0 / 0.2)", +"lch(-10 -10 360 / 1)", "lch(-10 -10 0)", +"lch(-10% -10% 360deg / 1)", "lch(-10 -15 0)", +"lch(0 0 380)", "lch(0 0 20)", +"lch(0% 0% 380deg)", "lch(0 0 20)", +"lch(0 0 380 / 0)", "lch(0 0 20 / 0)", +"lch(0% 0% 380deg / 0)", "lch(0 0 20 / 0)", +"lch(0 0 380 / 0.2)", "lch(0 0 20 / 0.2)", +"lch(0% 0% 380deg / 0.2)", "lch(0 0 20 / 0.2)", +"lch(0 0 380 / 1)", "lch(0 0 20)", +"lch(0% 0% 380deg / 1)", "lch(0 0 20)", +"lch(10 0 380)", "lch(10 0 20)", +"lch(10% 0% 380deg)", "lch(10 0 20)", +"lch(10 0 380 / 0)", "lch(10 0 20 / 0)", +"lch(10% 0% 380deg / 0)", "lch(10 0 20 / 0)", +"lch(10 0 380 / 0.2)", "lch(10 0 20 / 0.2)", +"lch(10% 0% 380deg / 0.2)", "lch(10 0 20 / 0.2)", +"lch(10 0 380 / 1)", "lch(10 0 20)", +"lch(10% 0% 380deg / 1)", "lch(10 0 20)", +"lch(110 0 380)", "lch(110 0 20)", +"lch(110% 0% 380deg)", "lch(110 0 20)", +"lch(110 0 380 / 0)", "lch(110 0 20 / 0)", +"lch(110% 0% 380deg / 0)", "lch(110 0 20 / 0)", +"lch(110 0 380 / 0.2)", "lch(110 0 20 / 0.2)", +"lch(110% 0% 380deg / 0.2)", "lch(110 0 20 / 0.2)", +"lch(110 0 380 / 1)", "lch(110 0 20)", +"lch(110% 0% 380deg / 1)", "lch(110 0 20)", +"lch(-10 0 380)", "lch(-10 0 20)", +"lch(-10% 0% 380deg)", "lch(-10 0 20)", +"lch(-10 0 380 / 0)", "lch(-10 0 20 / 0)", +"lch(-10% 0% 380deg / 0)", "lch(-10 0 20 / 0)", +"lch(-10 0 380 / 0.2)", "lch(-10 0 20 / 0.2)", +"lch(-10% 0% 380deg / 0.2)", "lch(-10 0 20 / 0.2)", +"lch(-10 0 380 / 1)", "lch(-10 0 20)", +"lch(-10% 0% 380deg / 1)", "lch(-10 0 20)", +"lch(0 10 380)", "lch(0 10 20)", +"lch(0% 10% 380deg)", "lch(0 15 20)", +"lch(0 10 380 / 0)", "lch(0 10 20 / 0)", +"lch(0% 10% 380deg / 0)", "lch(0 15 20 / 0)", +"lch(0 10 380 / 0.2)", "lch(0 10 20 / 0.2)", +"lch(0% 10% 380deg / 0.2)", "lch(0 15 20 / 0.2)", +"lch(0 10 380 / 1)", "lch(0 10 20)", +"lch(0% 10% 380deg / 1)", "lch(0 15 20)", +"lch(10 10 380)", "lch(10 10 20)", +"lch(10% 10% 380deg)", "lch(10 15 20)", +"lch(10 10 380 / 0)", "lch(10 10 20 / 0)", +"lch(10% 10% 380deg / 0)", "lch(10 15 20 / 0)", +"lch(10 10 380 / 0.2)", "lch(10 10 20 / 0.2)", +"lch(10% 10% 380deg / 0.2)", "lch(10 15 20 / 0.2)", +"lch(10 10 380 / 1)", "lch(10 10 20)", +"lch(10% 10% 380deg / 1)", "lch(10 15 20)", +"lch(110 10 380)", "lch(110 10 20)", +"lch(110% 10% 380deg)", "lch(110 15 20)", +"lch(110 10 380 / 0)", "lch(110 10 20 / 0)", +"lch(110% 10% 380deg / 0)", "lch(110 15 20 / 0)", +"lch(110 10 380 / 0.2)", "lch(110 10 20 / 0.2)", +"lch(110% 10% 380deg / 0.2)", "lch(110 15 20 / 0.2)", +"lch(110 10 380 / 1)", "lch(110 10 20)", +"lch(110% 10% 380deg / 1)", "lch(110 15 20)", +"lch(-10 10 380)", "lch(-10 10 20)", +"lch(-10% 10% 380deg)", "lch(-10 15 20)", +"lch(-10 10 380 / 0)", "lch(-10 10 20 / 0)", +"lch(-10% 10% 380deg / 0)", "lch(-10 15 20 / 0)", +"lch(-10 10 380 / 0.2)", "lch(-10 10 20 / 0.2)", +"lch(-10% 10% 380deg / 0.2)", "lch(-10 15 20 / 0.2)", +"lch(-10 10 380 / 1)", "lch(-10 10 20)", +"lch(-10% 10% 380deg / 1)", "lch(-10 15 20)", +"lch(0 110 380)", "lch(0 110 20)", +"lch(0% 110% 380deg)", "lch(0 165 20)", +"lch(0 110 380 / 0)", "lch(0 110 20 / 0)", +"lch(0% 110% 380deg / 0)", "lch(0 165 20 / 0)", +"lch(0 110 380 / 0.2)", "lch(0 110 20 / 0.2)", +"lch(0% 110% 380deg / 0.2)", "lch(0 165 20 / 0.2)", +"lch(0 110 380 / 1)", "lch(0 110 20)", +"lch(0% 110% 380deg / 1)", "lch(0 165 20)", +"lch(10 110 380)", "lch(10 110 20)", +"lch(10% 110% 380deg)", "lch(10 165 20)", +"lch(10 110 380 / 0)", "lch(10 110 20 / 0)", +"lch(10% 110% 380deg / 0)", "lch(10 165 20 / 0)", +"lch(10 110 380 / 0.2)", "lch(10 110 20 / 0.2)", +"lch(10% 110% 380deg / 0.2)", "lch(10 165 20 / 0.2)", +"lch(10 110 380 / 1)", "lch(10 110 20)", +"lch(10% 110% 380deg / 1)", "lch(10 165 20)", +"lch(110 110 380)", "lch(110 110 20)", +"lch(110% 110% 380deg)", "lch(110 165 20)", +"lch(110 110 380 / 0)", "lch(110 110 20 / 0)", +"lch(110% 110% 380deg / 0)", "lch(110 165 20 / 0)", +"lch(110 110 380 / 0.2)", "lch(110 110 20 / 0.2)", +"lch(110% 110% 380deg / 0.2)", "lch(110 165 20 / 0.2)", +"lch(110 110 380 / 1)", "lch(110 110 20)", +"lch(110% 110% 380deg / 1)", "lch(110 165 20)", +"lch(-10 110 380)", "lch(-10 110 20)", +"lch(-10% 110% 380deg)", "lch(-10 165 20)", +"lch(-10 110 380 / 0)", "lch(-10 110 20 / 0)", +"lch(-10% 110% 380deg / 0)", "lch(-10 165 20 / 0)", +"lch(-10 110 380 / 0.2)", "lch(-10 110 20 / 0.2)", +"lch(-10% 110% 380deg / 0.2)", "lch(-10 165 20 / 0.2)", +"lch(-10 110 380 / 1)", "lch(-10 110 20)", +"lch(-10% 110% 380deg / 1)", "lch(-10 165 20)", +"lch(0 -10 380)", "lch(0 -10 20)", +"lch(0% -10% 380deg)", "lch(0 -15 20)", +"lch(0 -10 380 / 0)", "lch(0 -10 20 / 0)", +"lch(0% -10% 380deg / 0)", "lch(0 -15 20 / 0)", +"lch(0 -10 380 / 0.2)", "lch(0 -10 20 / 0.2)", +"lch(0% -10% 380deg / 0.2)", "lch(0 -15 20 / 0.2)", +"lch(0 -10 380 / 1)", "lch(0 -10 20)", +"lch(0% -10% 380deg / 1)", "lch(0 -15 20)", +"lch(10 -10 380)", "lch(10 -10 20)", +"lch(10% -10% 380deg)", "lch(10 -15 20)", +"lch(10 -10 380 / 0)", "lch(10 -10 20 / 0)", +"lch(10% -10% 380deg / 0)", "lch(10 -15 20 / 0)", +"lch(10 -10 380 / 0.2)", "lch(10 -10 20 / 0.2)", +"lch(10% -10% 380deg / 0.2)", "lch(10 -15 20 / 0.2)", +"lch(10 -10 380 / 1)", "lch(10 -10 20)", +"lch(10% -10% 380deg / 1)", "lch(10 -15 20)", +"lch(110 -10 380)", "lch(110 -10 20)", +"lch(110% -10% 380deg)", "lch(110 -15 20)", +"lch(110 -10 380 / 0)", "lch(110 -10 20 / 0)", +"lch(110% -10% 380deg / 0)", "lch(110 -15 20 / 0)", +"lch(110 -10 380 / 0.2)", "lch(110 -10 20 / 0.2)", +"lch(110% -10% 380deg / 0.2)", "lch(110 -15 20 / 0.2)", +"lch(110 -10 380 / 1)", "lch(110 -10 20)", +"lch(110% -10% 380deg / 1)", "lch(110 -15 20)", +"lch(-10 -10 380)", "lch(-10 -10 20)", +"lch(-10% -10% 380deg)", "lch(-10 -15 20)", +"lch(-10 -10 380 / 0)", "lch(-10 -10 20 / 0)", +"lch(-10% -10% 380deg / 0)", "lch(-10 -15 20 / 0)", +"lch(-10 -10 380 / 0.2)", "lch(-10 -10 20 / 0.2)", +"lch(-10% -10% 380deg / 0.2)", "lch(-10 -15 20 / 0.2)", +"lch(-10 -10 380 / 1)", "lch(-10 -10 20)", +"lch(-10% -10% 380deg / 1)", "lch(-10 -15 20)", +"lch(0 0 700)", "lch(0 0 340)", +"lch(0% 0% 700deg)", "lch(0 0 340)", +"lch(0 0 700 / 0)", "lch(0 0 340 / 0)", +"lch(0% 0% 700deg / 0)", "lch(0 0 340 / 0)", +"lch(0 0 700 / 0.2)", "lch(0 0 340 / 0.2)", +"lch(0% 0% 700deg / 0.2)", "lch(0 0 340 / 0.2)", +"lch(0 0 700 / 1)", "lch(0 0 340)", +"lch(0% 0% 700deg / 1)", "lch(0 0 340)", +"lch(10 0 700)", "lch(10 0 340)", +"lch(10% 0% 700deg)", "lch(10 0 340)", +"lch(10 0 700 / 0)", "lch(10 0 340 / 0)", +"lch(10% 0% 700deg / 0)", "lch(10 0 340 / 0)", +"lch(10 0 700 / 0.2)", "lch(10 0 340 / 0.2)", +"lch(10% 0% 700deg / 0.2)", "lch(10 0 340 / 0.2)", +"lch(10 0 700 / 1)", "lch(10 0 340)", +"lch(10% 0% 700deg / 1)", "lch(10 0 340)", +"lch(110 0 700)", "lch(110 0 340)", +"lch(110% 0% 700deg)", "lch(110 0 340)", +"lch(110 0 700 / 0)", "lch(110 0 340 / 0)", +"lch(110% 0% 700deg / 0)", "lch(110 0 340 / 0)", +"lch(110 0 700 / 0.2)", "lch(110 0 340 / 0.2)", +"lch(110% 0% 700deg / 0.2)", "lch(110 0 340 / 0.2)", +"lch(110 0 700 / 1)", "lch(110 0 340)", +"lch(110% 0% 700deg / 1)", "lch(110 0 340)", +"lch(-10 0 700)", "lch(-10 0 340)", +"lch(-10% 0% 700deg)", "lch(-10 0 340)", +"lch(-10 0 700 / 0)", "lch(-10 0 340 / 0)", +"lch(-10% 0% 700deg / 0)", "lch(-10 0 340 / 0)", +"lch(-10 0 700 / 0.2)", "lch(-10 0 340 / 0.2)", +"lch(-10% 0% 700deg / 0.2)", "lch(-10 0 340 / 0.2)", +"lch(-10 0 700 / 1)", "lch(-10 0 340)", +"lch(-10% 0% 700deg / 1)", "lch(-10 0 340)", +"lch(0 10 700)", "lch(0 10 340)", +"lch(0% 10% 700deg)", "lch(0 15 340)", +"lch(0 10 700 / 0)", "lch(0 10 340 / 0)", +"lch(0% 10% 700deg / 0)", "lch(0 15 340 / 0)", +"lch(0 10 700 / 0.2)", "lch(0 10 340 / 0.2)", +"lch(0% 10% 700deg / 0.2)", "lch(0 15 340 / 0.2)", +"lch(0 10 700 / 1)", "lch(0 10 340)", +"lch(0% 10% 700deg / 1)", "lch(0 15 340)", +"lch(10 10 700)", "lch(10 10 340)", +"lch(10% 10% 700deg)", "lch(10 15 340)", +"lch(10 10 700 / 0)", "lch(10 10 340 / 0)", +"lch(10% 10% 700deg / 0)", "lch(10 15 340 / 0)", +"lch(10 10 700 / 0.2)", "lch(10 10 340 / 0.2)", +"lch(10% 10% 700deg / 0.2)", "lch(10 15 340 / 0.2)", +"lch(10 10 700 / 1)", "lch(10 10 340)", +"lch(10% 10% 700deg / 1)", "lch(10 15 340)", +"lch(110 10 700)", "lch(110 10 340)", +"lch(110% 10% 700deg)", "lch(110 15 340)", +"lch(110 10 700 / 0)", "lch(110 10 340 / 0)", +"lch(110% 10% 700deg / 0)", "lch(110 15 340 / 0)", +"lch(110 10 700 / 0.2)", "lch(110 10 340 / 0.2)", +"lch(110% 10% 700deg / 0.2)", "lch(110 15 340 / 0.2)", +"lch(110 10 700 / 1)", "lch(110 10 340)", +"lch(110% 10% 700deg / 1)", "lch(110 15 340)", +"lch(-10 10 700)", "lch(-10 10 340)", +"lch(-10% 10% 700deg)", "lch(-10 15 340)", +"lch(-10 10 700 / 0)", "lch(-10 10 340 / 0)", +"lch(-10% 10% 700deg / 0)", "lch(-10 15 340 / 0)", +"lch(-10 10 700 / 0.2)", "lch(-10 10 340 / 0.2)", +"lch(-10% 10% 700deg / 0.2)", "lch(-10 15 340 / 0.2)", +"lch(-10 10 700 / 1)", "lch(-10 10 340)", +"lch(-10% 10% 700deg / 1)", "lch(-10 15 340)", +"lch(0 110 700)", "lch(0 110 340)", +"lch(0% 110% 700deg)", "lch(0 165 340)", +"lch(0 110 700 / 0)", "lch(0 110 340 / 0)", +"lch(0% 110% 700deg / 0)", "lch(0 165 340 / 0)", +"lch(0 110 700 / 0.2)", "lch(0 110 340 / 0.2)", +"lch(0% 110% 700deg / 0.2)", "lch(0 165 340 / 0.2)", +"lch(0 110 700 / 1)", "lch(0 110 340)", +"lch(0% 110% 700deg / 1)", "lch(0 165 340)", +"lch(10 110 700)", "lch(10 110 340)", +"lch(10% 110% 700deg)", "lch(10 165 340)", +"lch(10 110 700 / 0)", "lch(10 110 340 / 0)", +"lch(10% 110% 700deg / 0)", "lch(10 165 340 / 0)", +"lch(10 110 700 / 0.2)", "lch(10 110 340 / 0.2)", +"lch(10% 110% 700deg / 0.2)", "lch(10 165 340 / 0.2)", +"lch(10 110 700 / 1)", "lch(10 110 340)", +"lch(10% 110% 700deg / 1)", "lch(10 165 340)", +"lch(110 110 700)", "lch(110 110 340)", +"lch(110% 110% 700deg)", "lch(110 165 340)", +"lch(110 110 700 / 0)", "lch(110 110 340 / 0)", +"lch(110% 110% 700deg / 0)", "lch(110 165 340 / 0)", +"lch(110 110 700 / 0.2)", "lch(110 110 340 / 0.2)", +"lch(110% 110% 700deg / 0.2)", "lch(110 165 340 / 0.2)", +"lch(110 110 700 / 1)", "lch(110 110 340)", +"lch(110% 110% 700deg / 1)", "lch(110 165 340)", +"lch(-10 110 700)", "lch(-10 110 340)", +"lch(-10% 110% 700deg)", "lch(-10 165 340)", +"lch(-10 110 700 / 0)", "lch(-10 110 340 / 0)", +"lch(-10% 110% 700deg / 0)", "lch(-10 165 340 / 0)", +"lch(-10 110 700 / 0.2)", "lch(-10 110 340 / 0.2)", +"lch(-10% 110% 700deg / 0.2)", "lch(-10 165 340 / 0.2)", +"lch(-10 110 700 / 1)", "lch(-10 110 340)", +"lch(-10% 110% 700deg / 1)", "lch(-10 165 340)", +"lch(0 -10 700)", "lch(0 -10 340)", +"lch(0% -10% 700deg)", "lch(0 -15 340)", +"lch(0 -10 700 / 0)", "lch(0 -10 340 / 0)", +"lch(0% -10% 700deg / 0)", "lch(0 -15 340 / 0)", +"lch(0 -10 700 / 0.2)", "lch(0 -10 340 / 0.2)", +"lch(0% -10% 700deg / 0.2)", "lch(0 -15 340 / 0.2)", +"lch(0 -10 700 / 1)", "lch(0 -10 340)", +"lch(0% -10% 700deg / 1)", "lch(0 -15 340)", +"lch(10 -10 700)", "lch(10 -10 340)", +"lch(10% -10% 700deg)", "lch(10 -15 340)", +"lch(10 -10 700 / 0)", "lch(10 -10 340 / 0)", +"lch(10% -10% 700deg / 0)", "lch(10 -15 340 / 0)", +"lch(10 -10 700 / 0.2)", "lch(10 -10 340 / 0.2)", +"lch(10% -10% 700deg / 0.2)", "lch(10 -15 340 / 0.2)", +"lch(10 -10 700 / 1)", "lch(10 -10 340)", +"lch(10% -10% 700deg / 1)", "lch(10 -15 340)", +"lch(110 -10 700)", "lch(110 -10 340)", +"lch(110% -10% 700deg)", "lch(110 -15 340)", +"lch(110 -10 700 / 0)", "lch(110 -10 340 / 0)", +"lch(110% -10% 700deg / 0)", "lch(110 -15 340 / 0)", +"lch(110 -10 700 / 0.2)", "lch(110 -10 340 / 0.2)", +"lch(110% -10% 700deg / 0.2)", "lch(110 -15 340 / 0.2)", +"lch(110 -10 700 / 1)", "lch(110 -10 340)", +"lch(110% -10% 700deg / 1)", "lch(110 -15 340)", +"lch(-10 -10 700)", "lch(-10 -10 340)", +"lch(-10% -10% 700deg)", "lch(-10 -15 340)", +"lch(-10 -10 700 / 0)", "lch(-10 -10 340 / 0)", +"lch(-10% -10% 700deg / 0)", "lch(-10 -15 340 / 0)", +"lch(-10 -10 700 / 0.2)", "lch(-10 -10 340 / 0.2)", +"lch(-10% -10% 700deg / 0.2)", "lch(-10 -15 340 / 0.2)", +"lch(-10 -10 700 / 1)", "lch(-10 -10 340)", +"lch(-10% -10% 700deg / 1)", "lch(-10 -15 340)", +"lch(0 0 -20)", "lch(0 0 340)", +"lch(0% 0% -20deg)", "lch(0 0 340)", +"lch(0 0 -20 / 0)", "lch(0 0 340 / 0)", +"lch(0% 0% -20deg / 0)", "lch(0 0 340 / 0)", +"lch(0 0 -20 / 0.2)", "lch(0 0 340 / 0.2)", +"lch(0% 0% -20deg / 0.2)", "lch(0 0 340 / 0.2)", +"lch(0 0 -20 / 1)", "lch(0 0 340)", +"lch(0% 0% -20deg / 1)", "lch(0 0 340)", +"lch(10 0 -20)", "lch(10 0 340)", +"lch(10% 0% -20deg)", "lch(10 0 340)", +"lch(10 0 -20 / 0)", "lch(10 0 340 / 0)", +"lch(10% 0% -20deg / 0)", "lch(10 0 340 / 0)", +"lch(10 0 -20 / 0.2)", "lch(10 0 340 / 0.2)", +"lch(10% 0% -20deg / 0.2)", "lch(10 0 340 / 0.2)", +"lch(10 0 -20 / 1)", "lch(10 0 340)", +"lch(10% 0% -20deg / 1)", "lch(10 0 340)", +"lch(110 0 -20)", "lch(110 0 340)", +"lch(110% 0% -20deg)", "lch(110 0 340)", +"lch(110 0 -20 / 0)", "lch(110 0 340 / 0)", +"lch(110% 0% -20deg / 0)", "lch(110 0 340 / 0)", +"lch(110 0 -20 / 0.2)", "lch(110 0 340 / 0.2)", +"lch(110% 0% -20deg / 0.2)", "lch(110 0 340 / 0.2)", +"lch(110 0 -20 / 1)", "lch(110 0 340)", +"lch(110% 0% -20deg / 1)", "lch(110 0 340)", +"lch(-10 0 -20)", "lch(-10 0 340)", +"lch(-10% 0% -20deg)", "lch(-10 0 340)", +"lch(-10 0 -20 / 0)", "lch(-10 0 340 / 0)", +"lch(-10% 0% -20deg / 0)", "lch(-10 0 340 / 0)", +"lch(-10 0 -20 / 0.2)", "lch(-10 0 340 / 0.2)", +"lch(-10% 0% -20deg / 0.2)", "lch(-10 0 340 / 0.2)", +"lch(-10 0 -20 / 1)", "lch(-10 0 340)", +"lch(-10% 0% -20deg / 1)", "lch(-10 0 340)", +"lch(0 10 -20)", "lch(0 10 340)", +"lch(0% 10% -20deg)", "lch(0 15 340)", +"lch(0 10 -20 / 0)", "lch(0 10 340 / 0)", +"lch(0% 10% -20deg / 0)", "lch(0 15 340 / 0)", +"lch(0 10 -20 / 0.2)", "lch(0 10 340 / 0.2)", +"lch(0% 10% -20deg / 0.2)", "lch(0 15 340 / 0.2)", +"lch(0 10 -20 / 1)", "lch(0 10 340)", +"lch(0% 10% -20deg / 1)", "lch(0 15 340)", +"lch(10 10 -20)", "lch(10 10 340)", +"lch(10% 10% -20deg)", "lch(10 15 340)", +"lch(10 10 -20 / 0)", "lch(10 10 340 / 0)", +"lch(10% 10% -20deg / 0)", "lch(10 15 340 / 0)", +"lch(10 10 -20 / 0.2)", "lch(10 10 340 / 0.2)", +"lch(10% 10% -20deg / 0.2)", "lch(10 15 340 / 0.2)", +"lch(10 10 -20 / 1)", "lch(10 10 340)", +"lch(10% 10% -20deg / 1)", "lch(10 15 340)", +"lch(110 10 -20)", "lch(110 10 340)", +"lch(110% 10% -20deg)", "lch(110 15 340)", +"lch(110 10 -20 / 0)", "lch(110 10 340 / 0)", +"lch(110% 10% -20deg / 0)", "lch(110 15 340 / 0)", +"lch(110 10 -20 / 0.2)", "lch(110 10 340 / 0.2)", +"lch(110% 10% -20deg / 0.2)", "lch(110 15 340 / 0.2)", +"lch(110 10 -20 / 1)", "lch(110 10 340)", +"lch(110% 10% -20deg / 1)", "lch(110 15 340)", +"lch(-10 10 -20)", "lch(-10 10 340)", +"lch(-10% 10% -20deg)", "lch(-10 15 340)", +"lch(-10 10 -20 / 0)", "lch(-10 10 340 / 0)", +"lch(-10% 10% -20deg / 0)", "lch(-10 15 340 / 0)", +"lch(-10 10 -20 / 0.2)", "lch(-10 10 340 / 0.2)", +"lch(-10% 10% -20deg / 0.2)", "lch(-10 15 340 / 0.2)", +"lch(-10 10 -20 / 1)", "lch(-10 10 340)", +"lch(-10% 10% -20deg / 1)", "lch(-10 15 340)", +"lch(0 110 -20)", "lch(0 110 340)", +"lch(0% 110% -20deg)", "lch(0 165 340)", +"lch(0 110 -20 / 0)", "lch(0 110 340 / 0)", +"lch(0% 110% -20deg / 0)", "lch(0 165 340 / 0)", +"lch(0 110 -20 / 0.2)", "lch(0 110 340 / 0.2)", +"lch(0% 110% -20deg / 0.2)", "lch(0 165 340 / 0.2)", +"lch(0 110 -20 / 1)", "lch(0 110 340)", +"lch(0% 110% -20deg / 1)", "lch(0 165 340)", +"lch(10 110 -20)", "lch(10 110 340)", +"lch(10% 110% -20deg)", "lch(10 165 340)", +"lch(10 110 -20 / 0)", "lch(10 110 340 / 0)", +"lch(10% 110% -20deg / 0)", "lch(10 165 340 / 0)", +"lch(10 110 -20 / 0.2)", "lch(10 110 340 / 0.2)", +"lch(10% 110% -20deg / 0.2)", "lch(10 165 340 / 0.2)", +"lch(10 110 -20 / 1)", "lch(10 110 340)", +"lch(10% 110% -20deg / 1)", "lch(10 165 340)", +"lch(110 110 -20)", "lch(110 110 340)", +"lch(110% 110% -20deg)", "lch(110 165 340)", +"lch(110 110 -20 / 0)", "lch(110 110 340 / 0)", +"lch(110% 110% -20deg / 0)", "lch(110 165 340 / 0)", +"lch(110 110 -20 / 0.2)", "lch(110 110 340 / 0.2)", +"lch(110% 110% -20deg / 0.2)", "lch(110 165 340 / 0.2)", +"lch(110 110 -20 / 1)", "lch(110 110 340)", +"lch(110% 110% -20deg / 1)", "lch(110 165 340)", +"lch(-10 110 -20)", "lch(-10 110 340)", +"lch(-10% 110% -20deg)", "lch(-10 165 340)", +"lch(-10 110 -20 / 0)", "lch(-10 110 340 / 0)", +"lch(-10% 110% -20deg / 0)", "lch(-10 165 340 / 0)", +"lch(-10 110 -20 / 0.2)", "lch(-10 110 340 / 0.2)", +"lch(-10% 110% -20deg / 0.2)", "lch(-10 165 340 / 0.2)", +"lch(-10 110 -20 / 1)", "lch(-10 110 340)", +"lch(-10% 110% -20deg / 1)", "lch(-10 165 340)", +"lch(0 -10 -20)", "lch(0 -10 340)", +"lch(0% -10% -20deg)", "lch(0 -15 340)", +"lch(0 -10 -20 / 0)", "lch(0 -10 340 / 0)", +"lch(0% -10% -20deg / 0)", "lch(0 -15 340 / 0)", +"lch(0 -10 -20 / 0.2)", "lch(0 -10 340 / 0.2)", +"lch(0% -10% -20deg / 0.2)", "lch(0 -15 340 / 0.2)", +"lch(0 -10 -20 / 1)", "lch(0 -10 340)", +"lch(0% -10% -20deg / 1)", "lch(0 -15 340)", +"lch(10 -10 -20)", "lch(10 -10 340)", +"lch(10% -10% -20deg)", "lch(10 -15 340)", +"lch(10 -10 -20 / 0)", "lch(10 -10 340 / 0)", +"lch(10% -10% -20deg / 0)", "lch(10 -15 340 / 0)", +"lch(10 -10 -20 / 0.2)", "lch(10 -10 340 / 0.2)", +"lch(10% -10% -20deg / 0.2)", "lch(10 -15 340 / 0.2)", +"lch(10 -10 -20 / 1)", "lch(10 -10 340)", +"lch(10% -10% -20deg / 1)", "lch(10 -15 340)", +"lch(110 -10 -20)", "lch(110 -10 340)", +"lch(110% -10% -20deg)", "lch(110 -15 340)", +"lch(110 -10 -20 / 0)", "lch(110 -10 340 / 0)", +"lch(110% -10% -20deg / 0)", "lch(110 -15 340 / 0)", +"lch(110 -10 -20 / 0.2)", "lch(110 -10 340 / 0.2)", +"lch(110% -10% -20deg / 0.2)", "lch(110 -15 340 / 0.2)", +"lch(110 -10 -20 / 1)", "lch(110 -10 340)", +"lch(110% -10% -20deg / 1)", "lch(110 -15 340)", +"lch(-10 -10 -20)", "lch(-10 -10 340)", +"lch(-10% -10% -20deg)", "lch(-10 -15 340)", +"lch(-10 -10 -20 / 0)", "lch(-10 -10 340 / 0)", +"lch(-10% -10% -20deg / 0)", "lch(-10 -15 340 / 0)", +"lch(-10 -10 -20 / 0.2)", "lch(-10 -10 340 / 0.2)", +"lch(-10% -10% -20deg / 0.2)", "lch(-10 -15 340 / 0.2)", +"lch(-10 -10 -20 / 1)", "lch(-10 -10 340)", +"lch(-10% -10% -20deg / 1)", "lch(-10 -15 340)", +"oklch(0 0 0)", "oklch(0 0 0)", +"oklch(0% 0% 0deg)", "oklch(0 0 0)", +"oklch(0 0 0 / 0)", "oklch(0 0 0 / 0)", +"oklch(0% 0% 0deg / 0)", "oklch(0 0 0 / 0)", +"oklch(0 0 0 / 0.2)", "oklch(0 0 0 / 0.2)", +"oklch(0% 0% 0deg / 0.2)", "oklch(0 0 0 / 0.2)", +"oklch(0 0 0 / 1)", "oklch(0 0 0)", +"oklch(0% 0% 0deg / 1)", "oklch(0 0 0)", +"oklch(10 0 0)", "oklch(10 0 0)", +"oklch(10% 0% 0deg)", "oklch(0.1 0 0)", +"oklch(10 0 0 / 0)", "oklch(10 0 0 / 0)", +"oklch(10% 0% 0deg / 0)", "oklch(0.1 0 0 / 0)", +"oklch(10 0 0 / 0.2)", "oklch(10 0 0 / 0.2)", +"oklch(10% 0% 0deg / 0.2)", "oklch(0.1 0 0 / 0.2)", +"oklch(10 0 0 / 1)", "oklch(10 0 0)", +"oklch(10% 0% 0deg / 1)", "oklch(0.1 0 0)", +"oklch(110 0 0)", "oklch(110 0 0)", +"oklch(110% 0% 0deg)", "oklch(1.1 0 0)", +"oklch(110 0 0 / 0)", "oklch(110 0 0 / 0)", +"oklch(110% 0% 0deg / 0)", "oklch(1.1 0 0 / 0)", +"oklch(110 0 0 / 0.2)", "oklch(110 0 0 / 0.2)", +"oklch(110% 0% 0deg / 0.2)", "oklch(1.1 0 0 / 0.2)", +"oklch(110 0 0 / 1)", "oklch(110 0 0)", +"oklch(110% 0% 0deg / 1)", "oklch(1.1 0 0)", +"oklch(-10 0 0)", "oklch(-10 0 0)", +"oklch(-10% 0% 0deg)", "oklch(-0.1 0 0)", +"oklch(-10 0 0 / 0)", "oklch(-10 0 0 / 0)", +"oklch(-10% 0% 0deg / 0)", "oklch(-0.1 0 0 / 0)", +"oklch(-10 0 0 / 0.2)", "oklch(-10 0 0 / 0.2)", +"oklch(-10% 0% 0deg / 0.2)", "oklch(-0.1 0 0 / 0.2)", +"oklch(-10 0 0 / 1)", "oklch(-10 0 0)", +"oklch(-10% 0% 0deg / 1)", "oklch(-0.1 0 0)", +"oklch(0 10 0)", "oklch(0 10 0)", +"oklch(0% 10% 0deg)", "oklch(0 0.04 0)", +"oklch(0 10 0 / 0)", "oklch(0 10 0 / 0)", +"oklch(0% 10% 0deg / 0)", "oklch(0 0.04 0 / 0)", +"oklch(0 10 0 / 0.2)", "oklch(0 10 0 / 0.2)", +"oklch(0% 10% 0deg / 0.2)", "oklch(0 0.04 0 / 0.2)", +"oklch(0 10 0 / 1)", "oklch(0 10 0)", +"oklch(0% 10% 0deg / 1)", "oklch(0 0.04 0)", +"oklch(10 10 0)", "oklch(10 10 0)", +"oklch(10% 10% 0deg)", "oklch(0.1 0.04 0)", +"oklch(10 10 0 / 0)", "oklch(10 10 0 / 0)", +"oklch(10% 10% 0deg / 0)", "oklch(0.1 0.04 0 / 0)", +"oklch(10 10 0 / 0.2)", "oklch(10 10 0 / 0.2)", +"oklch(10% 10% 0deg / 0.2)", "oklch(0.1 0.04 0 / 0.2)", +"oklch(10 10 0 / 1)", "oklch(10 10 0)", +"oklch(10% 10% 0deg / 1)", "oklch(0.1 0.04 0)", +"oklch(110 10 0)", "oklch(110 10 0)", +"oklch(110% 10% 0deg)", "oklch(1.1 0.04 0)", +"oklch(110 10 0 / 0)", "oklch(110 10 0 / 0)", +"oklch(110% 10% 0deg / 0)", "oklch(1.1 0.04 0 / 0)", +"oklch(110 10 0 / 0.2)", "oklch(110 10 0 / 0.2)", +"oklch(110% 10% 0deg / 0.2)", "oklch(1.1 0.04 0 / 0.2)", +"oklch(110 10 0 / 1)", "oklch(110 10 0)", +"oklch(110% 10% 0deg / 1)", "oklch(1.1 0.04 0)", +"oklch(-10 10 0)", "oklch(-10 10 0)", +"oklch(-10% 10% 0deg)", "oklch(-0.1 0.04 0)", +"oklch(-10 10 0 / 0)", "oklch(-10 10 0 / 0)", +"oklch(-10% 10% 0deg / 0)", "oklch(-0.1 0.04 0 / 0)", +"oklch(-10 10 0 / 0.2)", "oklch(-10 10 0 / 0.2)", +"oklch(-10% 10% 0deg / 0.2)", "oklch(-0.1 0.04 0 / 0.2)", +"oklch(-10 10 0 / 1)", "oklch(-10 10 0)", +"oklch(-10% 10% 0deg / 1)", "oklch(-0.1 0.04 0)", +"oklch(0 110 0)", "oklch(0 110 0)", +"oklch(0% 110% 0deg)", "oklch(0 0.44 0)", +"oklch(0 110 0 / 0)", "oklch(0 110 0 / 0)", +"oklch(0% 110% 0deg / 0)", "oklch(0 0.44 0 / 0)", +"oklch(0 110 0 / 0.2)", "oklch(0 110 0 / 0.2)", +"oklch(0% 110% 0deg / 0.2)", "oklch(0 0.44 0 / 0.2)", +"oklch(0 110 0 / 1)", "oklch(0 110 0)", +"oklch(0% 110% 0deg / 1)", "oklch(0 0.44 0)", +"oklch(10 110 0)", "oklch(10 110 0)", +"oklch(10% 110% 0deg)", "oklch(0.1 0.44 0)", +"oklch(10 110 0 / 0)", "oklch(10 110 0 / 0)", +"oklch(10% 110% 0deg / 0)", "oklch(0.1 0.44 0 / 0)", +"oklch(10 110 0 / 0.2)", "oklch(10 110 0 / 0.2)", +"oklch(10% 110% 0deg / 0.2)", "oklch(0.1 0.44 0 / 0.2)", +"oklch(10 110 0 / 1)", "oklch(10 110 0)", +"oklch(10% 110% 0deg / 1)", "oklch(0.1 0.44 0)", +"oklch(110 110 0)", "oklch(110 110 0)", +"oklch(110% 110% 0deg)", "oklch(1.1 0.44 0)", +"oklch(110 110 0 / 0)", "oklch(110 110 0 / 0)", +"oklch(110% 110% 0deg / 0)", "oklch(1.1 0.44 0 / 0)", +"oklch(110 110 0 / 0.2)", "oklch(110 110 0 / 0.2)", +"oklch(110% 110% 0deg / 0.2)", "oklch(1.1 0.44 0 / 0.2)", +"oklch(110 110 0 / 1)", "oklch(110 110 0)", +"oklch(110% 110% 0deg / 1)", "oklch(1.1 0.44 0)", +"oklch(-10 110 0)", "oklch(-10 110 0)", +"oklch(-10% 110% 0deg)", "oklch(-0.1 0.44 0)", +"oklch(-10 110 0 / 0)", "oklch(-10 110 0 / 0)", +"oklch(-10% 110% 0deg / 0)", "oklch(-0.1 0.44 0 / 0)", +"oklch(-10 110 0 / 0.2)", "oklch(-10 110 0 / 0.2)", +"oklch(-10% 110% 0deg / 0.2)", "oklch(-0.1 0.44 0 / 0.2)", +"oklch(-10 110 0 / 1)", "oklch(-10 110 0)", +"oklch(-10% 110% 0deg / 1)", "oklch(-0.1 0.44 0)", +"oklch(0 -10 0)", "oklch(0 -10 0)", +"oklch(0% -10% 0deg)", "oklch(0 -0.04 0)", +"oklch(0 -10 0 / 0)", "oklch(0 -10 0 / 0)", +"oklch(0% -10% 0deg / 0)", "oklch(0 -0.04 0 / 0)", +"oklch(0 -10 0 / 0.2)", "oklch(0 -10 0 / 0.2)", +"oklch(0% -10% 0deg / 0.2)", "oklch(0 -0.04 0 / 0.2)", +"oklch(0 -10 0 / 1)", "oklch(0 -10 0)", +"oklch(0% -10% 0deg / 1)", "oklch(0 -0.04 0)", +"oklch(10 -10 0)", "oklch(10 -10 0)", +"oklch(10% -10% 0deg)", "oklch(0.1 -0.04 0)", +"oklch(10 -10 0 / 0)", "oklch(10 -10 0 / 0)", +"oklch(10% -10% 0deg / 0)", "oklch(0.1 -0.04 0 / 0)", +"oklch(10 -10 0 / 0.2)", "oklch(10 -10 0 / 0.2)", +"oklch(10% -10% 0deg / 0.2)", "oklch(0.1 -0.04 0 / 0.2)", +"oklch(10 -10 0 / 1)", "oklch(10 -10 0)", +"oklch(10% -10% 0deg / 1)", "oklch(0.1 -0.04 0)", +"oklch(110 -10 0)", "oklch(110 -10 0)", +"oklch(110% -10% 0deg)", "oklch(1.1 -0.04 0)", +"oklch(110 -10 0 / 0)", "oklch(110 -10 0 / 0)", +"oklch(110% -10% 0deg / 0)", "oklch(1.1 -0.04 0 / 0)", +"oklch(110 -10 0 / 0.2)", "oklch(110 -10 0 / 0.2)", +"oklch(110% -10% 0deg / 0.2)", "oklch(1.1 -0.04 0 / 0.2)", +"oklch(110 -10 0 / 1)", "oklch(110 -10 0)", +"oklch(110% -10% 0deg / 1)", "oklch(1.1 -0.04 0)", +"oklch(-10 -10 0)", "oklch(-10 -10 0)", +"oklch(-10% -10% 0deg)", "oklch(-0.1 -0.04 0)", +"oklch(-10 -10 0 / 0)", "oklch(-10 -10 0 / 0)", +"oklch(-10% -10% 0deg / 0)", "oklch(-0.1 -0.04 0 / 0)", +"oklch(-10 -10 0 / 0.2)", "oklch(-10 -10 0 / 0.2)", +"oklch(-10% -10% 0deg / 0.2)", "oklch(-0.1 -0.04 0 / 0.2)", +"oklch(-10 -10 0 / 1)", "oklch(-10 -10 0)", +"oklch(-10% -10% 0deg / 1)", "oklch(-0.1 -0.04 0)", +"oklch(0 0 30)", "oklch(0 0 30)", +"oklch(0% 0% 30deg)", "oklch(0 0 30)", +"oklch(0 0 30 / 0)", "oklch(0 0 30 / 0)", +"oklch(0% 0% 30deg / 0)", "oklch(0 0 30 / 0)", +"oklch(0 0 30 / 0.2)", "oklch(0 0 30 / 0.2)", +"oklch(0% 0% 30deg / 0.2)", "oklch(0 0 30 / 0.2)", +"oklch(0 0 30 / 1)", "oklch(0 0 30)", +"oklch(0% 0% 30deg / 1)", "oklch(0 0 30)", +"oklch(10 0 30)", "oklch(10 0 30)", +"oklch(10% 0% 30deg)", "oklch(0.1 0 30)", +"oklch(10 0 30 / 0)", "oklch(10 0 30 / 0)", +"oklch(10% 0% 30deg / 0)", "oklch(0.1 0 30 / 0)", +"oklch(10 0 30 / 0.2)", "oklch(10 0 30 / 0.2)", +"oklch(10% 0% 30deg / 0.2)", "oklch(0.1 0 30 / 0.2)", +"oklch(10 0 30 / 1)", "oklch(10 0 30)", +"oklch(10% 0% 30deg / 1)", "oklch(0.1 0 30)", +"oklch(110 0 30)", "oklch(110 0 30)", +"oklch(110% 0% 30deg)", "oklch(1.1 0 30)", +"oklch(110 0 30 / 0)", "oklch(110 0 30 / 0)", +"oklch(110% 0% 30deg / 0)", "oklch(1.1 0 30 / 0)", +"oklch(110 0 30 / 0.2)", "oklch(110 0 30 / 0.2)", +"oklch(110% 0% 30deg / 0.2)", "oklch(1.1 0 30 / 0.2)", +"oklch(110 0 30 / 1)", "oklch(110 0 30)", +"oklch(110% 0% 30deg / 1)", "oklch(1.1 0 30)", +"oklch(-10 0 30)", "oklch(-10 0 30)", +"oklch(-10% 0% 30deg)", "oklch(-0.1 0 30)", +"oklch(-10 0 30 / 0)", "oklch(-10 0 30 / 0)", +"oklch(-10% 0% 30deg / 0)", "oklch(-0.1 0 30 / 0)", +"oklch(-10 0 30 / 0.2)", "oklch(-10 0 30 / 0.2)", +"oklch(-10% 0% 30deg / 0.2)", "oklch(-0.1 0 30 / 0.2)", +"oklch(-10 0 30 / 1)", "oklch(-10 0 30)", +"oklch(-10% 0% 30deg / 1)", "oklch(-0.1 0 30)", +"oklch(0 10 30)", "oklch(0 10 30)", +"oklch(0% 10% 30deg)", "oklch(0 0.04 30)", +"oklch(0 10 30 / 0)", "oklch(0 10 30 / 0)", +"oklch(0% 10% 30deg / 0)", "oklch(0 0.04 30 / 0)", +"oklch(0 10 30 / 0.2)", "oklch(0 10 30 / 0.2)", +"oklch(0% 10% 30deg / 0.2)", "oklch(0 0.04 30 / 0.2)", +"oklch(0 10 30 / 1)", "oklch(0 10 30)", +"oklch(0% 10% 30deg / 1)", "oklch(0 0.04 30)", +"oklch(10 10 30)", "oklch(10 10 30)", +"oklch(10% 10% 30deg)", "oklch(0.1 0.04 30)", +"oklch(10 10 30 / 0)", "oklch(10 10 30 / 0)", +"oklch(10% 10% 30deg / 0)", "oklch(0.1 0.04 30 / 0)", +"oklch(10 10 30 / 0.2)", "oklch(10 10 30 / 0.2)", +"oklch(10% 10% 30deg / 0.2)", "oklch(0.1 0.04 30 / 0.2)", +"oklch(10 10 30 / 1)", "oklch(10 10 30)", +"oklch(10% 10% 30deg / 1)", "oklch(0.1 0.04 30)", +"oklch(110 10 30)", "oklch(110 10 30)", +"oklch(110% 10% 30deg)", "oklch(1.1 0.04 30)", +"oklch(110 10 30 / 0)", "oklch(110 10 30 / 0)", +"oklch(110% 10% 30deg / 0)", "oklch(1.1 0.04 30 / 0)", +"oklch(110 10 30 / 0.2)", "oklch(110 10 30 / 0.2)", +"oklch(110% 10% 30deg / 0.2)", "oklch(1.1 0.04 30 / 0.2)", +"oklch(110 10 30 / 1)", "oklch(110 10 30)", +"oklch(110% 10% 30deg / 1)", "oklch(1.1 0.04 30)", +"oklch(-10 10 30)", "oklch(-10 10 30)", +"oklch(-10% 10% 30deg)", "oklch(-0.1 0.04 30)", +"oklch(-10 10 30 / 0)", "oklch(-10 10 30 / 0)", +"oklch(-10% 10% 30deg / 0)", "oklch(-0.1 0.04 30 / 0)", +"oklch(-10 10 30 / 0.2)", "oklch(-10 10 30 / 0.2)", +"oklch(-10% 10% 30deg / 0.2)", "oklch(-0.1 0.04 30 / 0.2)", +"oklch(-10 10 30 / 1)", "oklch(-10 10 30)", +"oklch(-10% 10% 30deg / 1)", "oklch(-0.1 0.04 30)", +"oklch(0 110 30)", "oklch(0 110 30)", +"oklch(0% 110% 30deg)", "oklch(0 0.44 30)", +"oklch(0 110 30 / 0)", "oklch(0 110 30 / 0)", +"oklch(0% 110% 30deg / 0)", "oklch(0 0.44 30 / 0)", +"oklch(0 110 30 / 0.2)", "oklch(0 110 30 / 0.2)", +"oklch(0% 110% 30deg / 0.2)", "oklch(0 0.44 30 / 0.2)", +"oklch(0 110 30 / 1)", "oklch(0 110 30)", +"oklch(0% 110% 30deg / 1)", "oklch(0 0.44 30)", +"oklch(10 110 30)", "oklch(10 110 30)", +"oklch(10% 110% 30deg)", "oklch(0.1 0.44 30)", +"oklch(10 110 30 / 0)", "oklch(10 110 30 / 0)", +"oklch(10% 110% 30deg / 0)", "oklch(0.1 0.44 30 / 0)", +"oklch(10 110 30 / 0.2)", "oklch(10 110 30 / 0.2)", +"oklch(10% 110% 30deg / 0.2)", "oklch(0.1 0.44 30 / 0.2)", +"oklch(10 110 30 / 1)", "oklch(10 110 30)", +"oklch(10% 110% 30deg / 1)", "oklch(0.1 0.44 30)", +"oklch(110 110 30)", "oklch(110 110 30)", +"oklch(110% 110% 30deg)", "oklch(1.1 0.44 30)", +"oklch(110 110 30 / 0)", "oklch(110 110 30 / 0)", +"oklch(110% 110% 30deg / 0)", "oklch(1.1 0.44 30 / 0)", +"oklch(110 110 30 / 0.2)", "oklch(110 110 30 / 0.2)", +"oklch(110% 110% 30deg / 0.2)", "oklch(1.1 0.44 30 / 0.2)", +"oklch(110 110 30 / 1)", "oklch(110 110 30)", +"oklch(110% 110% 30deg / 1)", "oklch(1.1 0.44 30)", +"oklch(-10 110 30)", "oklch(-10 110 30)", +"oklch(-10% 110% 30deg)", "oklch(-0.1 0.44 30)", +"oklch(-10 110 30 / 0)", "oklch(-10 110 30 / 0)", +"oklch(-10% 110% 30deg / 0)", "oklch(-0.1 0.44 30 / 0)", +"oklch(-10 110 30 / 0.2)", "oklch(-10 110 30 / 0.2)", +"oklch(-10% 110% 30deg / 0.2)", "oklch(-0.1 0.44 30 / 0.2)", +"oklch(-10 110 30 / 1)", "oklch(-10 110 30)", +"oklch(-10% 110% 30deg / 1)", "oklch(-0.1 0.44 30)", +"oklch(0 -10 30)", "oklch(0 -10 30)", +"oklch(0% -10% 30deg)", "oklch(0 -0.04 30)", +"oklch(0 -10 30 / 0)", "oklch(0 -10 30 / 0)", +"oklch(0% -10% 30deg / 0)", "oklch(0 -0.04 30 / 0)", +"oklch(0 -10 30 / 0.2)", "oklch(0 -10 30 / 0.2)", +"oklch(0% -10% 30deg / 0.2)", "oklch(0 -0.04 30 / 0.2)", +"oklch(0 -10 30 / 1)", "oklch(0 -10 30)", +"oklch(0% -10% 30deg / 1)", "oklch(0 -0.04 30)", +"oklch(10 -10 30)", "oklch(10 -10 30)", +"oklch(10% -10% 30deg)", "oklch(0.1 -0.04 30)", +"oklch(10 -10 30 / 0)", "oklch(10 -10 30 / 0)", +"oklch(10% -10% 30deg / 0)", "oklch(0.1 -0.04 30 / 0)", +"oklch(10 -10 30 / 0.2)", "oklch(10 -10 30 / 0.2)", +"oklch(10% -10% 30deg / 0.2)", "oklch(0.1 -0.04 30 / 0.2)", +"oklch(10 -10 30 / 1)", "oklch(10 -10 30)", +"oklch(10% -10% 30deg / 1)", "oklch(0.1 -0.04 30)", +"oklch(110 -10 30)", "oklch(110 -10 30)", +"oklch(110% -10% 30deg)", "oklch(1.1 -0.04 30)", +"oklch(110 -10 30 / 0)", "oklch(110 -10 30 / 0)", +"oklch(110% -10% 30deg / 0)", "oklch(1.1 -0.04 30 / 0)", +"oklch(110 -10 30 / 0.2)", "oklch(110 -10 30 / 0.2)", +"oklch(110% -10% 30deg / 0.2)", "oklch(1.1 -0.04 30 / 0.2)", +"oklch(110 -10 30 / 1)", "oklch(110 -10 30)", +"oklch(110% -10% 30deg / 1)", "oklch(1.1 -0.04 30)", +"oklch(-10 -10 30)", "oklch(-10 -10 30)", +"oklch(-10% -10% 30deg)", "oklch(-0.1 -0.04 30)", +"oklch(-10 -10 30 / 0)", "oklch(-10 -10 30 / 0)", +"oklch(-10% -10% 30deg / 0)", "oklch(-0.1 -0.04 30 / 0)", +"oklch(-10 -10 30 / 0.2)", "oklch(-10 -10 30 / 0.2)", +"oklch(-10% -10% 30deg / 0.2)", "oklch(-0.1 -0.04 30 / 0.2)", +"oklch(-10 -10 30 / 1)", "oklch(-10 -10 30)", +"oklch(-10% -10% 30deg / 1)", "oklch(-0.1 -0.04 30)", +"oklch(0 0 60)", "oklch(0 0 60)", +"oklch(0% 0% 60deg)", "oklch(0 0 60)", +"oklch(0 0 60 / 0)", "oklch(0 0 60 / 0)", +"oklch(0% 0% 60deg / 0)", "oklch(0 0 60 / 0)", +"oklch(0 0 60 / 0.2)", "oklch(0 0 60 / 0.2)", +"oklch(0% 0% 60deg / 0.2)", "oklch(0 0 60 / 0.2)", +"oklch(0 0 60 / 1)", "oklch(0 0 60)", +"oklch(0% 0% 60deg / 1)", "oklch(0 0 60)", +"oklch(10 0 60)", "oklch(10 0 60)", +"oklch(10% 0% 60deg)", "oklch(0.1 0 60)", +"oklch(10 0 60 / 0)", "oklch(10 0 60 / 0)", +"oklch(10% 0% 60deg / 0)", "oklch(0.1 0 60 / 0)", +"oklch(10 0 60 / 0.2)", "oklch(10 0 60 / 0.2)", +"oklch(10% 0% 60deg / 0.2)", "oklch(0.1 0 60 / 0.2)", +"oklch(10 0 60 / 1)", "oklch(10 0 60)", +"oklch(10% 0% 60deg / 1)", "oklch(0.1 0 60)", +"oklch(110 0 60)", "oklch(110 0 60)", +"oklch(110% 0% 60deg)", "oklch(1.1 0 60)", +"oklch(110 0 60 / 0)", "oklch(110 0 60 / 0)", +"oklch(110% 0% 60deg / 0)", "oklch(1.1 0 60 / 0)", +"oklch(110 0 60 / 0.2)", "oklch(110 0 60 / 0.2)", +"oklch(110% 0% 60deg / 0.2)", "oklch(1.1 0 60 / 0.2)", +"oklch(110 0 60 / 1)", "oklch(110 0 60)", +"oklch(110% 0% 60deg / 1)", "oklch(1.1 0 60)", +"oklch(-10 0 60)", "oklch(-10 0 60)", +"oklch(-10% 0% 60deg)", "oklch(-0.1 0 60)", +"oklch(-10 0 60 / 0)", "oklch(-10 0 60 / 0)", +"oklch(-10% 0% 60deg / 0)", "oklch(-0.1 0 60 / 0)", +"oklch(-10 0 60 / 0.2)", "oklch(-10 0 60 / 0.2)", +"oklch(-10% 0% 60deg / 0.2)", "oklch(-0.1 0 60 / 0.2)", +"oklch(-10 0 60 / 1)", "oklch(-10 0 60)", +"oklch(-10% 0% 60deg / 1)", "oklch(-0.1 0 60)", +"oklch(0 10 60)", "oklch(0 10 60)", +"oklch(0% 10% 60deg)", "oklch(0 0.04 60)", +"oklch(0 10 60 / 0)", "oklch(0 10 60 / 0)", +"oklch(0% 10% 60deg / 0)", "oklch(0 0.04 60 / 0)", +"oklch(0 10 60 / 0.2)", "oklch(0 10 60 / 0.2)", +"oklch(0% 10% 60deg / 0.2)", "oklch(0 0.04 60 / 0.2)", +"oklch(0 10 60 / 1)", "oklch(0 10 60)", +"oklch(0% 10% 60deg / 1)", "oklch(0 0.04 60)", +"oklch(10 10 60)", "oklch(10 10 60)", +"oklch(10% 10% 60deg)", "oklch(0.1 0.04 60)", +"oklch(10 10 60 / 0)", "oklch(10 10 60 / 0)", +"oklch(10% 10% 60deg / 0)", "oklch(0.1 0.04 60 / 0)", +"oklch(10 10 60 / 0.2)", "oklch(10 10 60 / 0.2)", +"oklch(10% 10% 60deg / 0.2)", "oklch(0.1 0.04 60 / 0.2)", +"oklch(10 10 60 / 1)", "oklch(10 10 60)", +"oklch(10% 10% 60deg / 1)", "oklch(0.1 0.04 60)", +"oklch(110 10 60)", "oklch(110 10 60)", +"oklch(110% 10% 60deg)", "oklch(1.1 0.04 60)", +"oklch(110 10 60 / 0)", "oklch(110 10 60 / 0)", +"oklch(110% 10% 60deg / 0)", "oklch(1.1 0.04 60 / 0)", +"oklch(110 10 60 / 0.2)", "oklch(110 10 60 / 0.2)", +"oklch(110% 10% 60deg / 0.2)", "oklch(1.1 0.04 60 / 0.2)", +"oklch(110 10 60 / 1)", "oklch(110 10 60)", +"oklch(110% 10% 60deg / 1)", "oklch(1.1 0.04 60)", +"oklch(-10 10 60)", "oklch(-10 10 60)", +"oklch(-10% 10% 60deg)", "oklch(-0.1 0.04 60)", +"oklch(-10 10 60 / 0)", "oklch(-10 10 60 / 0)", +"oklch(-10% 10% 60deg / 0)", "oklch(-0.1 0.04 60 / 0)", +"oklch(-10 10 60 / 0.2)", "oklch(-10 10 60 / 0.2)", +"oklch(-10% 10% 60deg / 0.2)", "oklch(-0.1 0.04 60 / 0.2)", +"oklch(-10 10 60 / 1)", "oklch(-10 10 60)", +"oklch(-10% 10% 60deg / 1)", "oklch(-0.1 0.04 60)", +"oklch(0 110 60)", "oklch(0 110 60)", +"oklch(0% 110% 60deg)", "oklch(0 0.44 60)", +"oklch(0 110 60 / 0)", "oklch(0 110 60 / 0)", +"oklch(0% 110% 60deg / 0)", "oklch(0 0.44 60 / 0)", +"oklch(0 110 60 / 0.2)", "oklch(0 110 60 / 0.2)", +"oklch(0% 110% 60deg / 0.2)", "oklch(0 0.44 60 / 0.2)", +"oklch(0 110 60 / 1)", "oklch(0 110 60)", +"oklch(0% 110% 60deg / 1)", "oklch(0 0.44 60)", +"oklch(10 110 60)", "oklch(10 110 60)", +"oklch(10% 110% 60deg)", "oklch(0.1 0.44 60)", +"oklch(10 110 60 / 0)", "oklch(10 110 60 / 0)", +"oklch(10% 110% 60deg / 0)", "oklch(0.1 0.44 60 / 0)", +"oklch(10 110 60 / 0.2)", "oklch(10 110 60 / 0.2)", +"oklch(10% 110% 60deg / 0.2)", "oklch(0.1 0.44 60 / 0.2)", +"oklch(10 110 60 / 1)", "oklch(10 110 60)", +"oklch(10% 110% 60deg / 1)", "oklch(0.1 0.44 60)", +"oklch(110 110 60)", "oklch(110 110 60)", +"oklch(110% 110% 60deg)", "oklch(1.1 0.44 60)", +"oklch(110 110 60 / 0)", "oklch(110 110 60 / 0)", +"oklch(110% 110% 60deg / 0)", "oklch(1.1 0.44 60 / 0)", +"oklch(110 110 60 / 0.2)", "oklch(110 110 60 / 0.2)", +"oklch(110% 110% 60deg / 0.2)", "oklch(1.1 0.44 60 / 0.2)", +"oklch(110 110 60 / 1)", "oklch(110 110 60)", +"oklch(110% 110% 60deg / 1)", "oklch(1.1 0.44 60)", +"oklch(-10 110 60)", "oklch(-10 110 60)", +"oklch(-10% 110% 60deg)", "oklch(-0.1 0.44 60)", +"oklch(-10 110 60 / 0)", "oklch(-10 110 60 / 0)", +"oklch(-10% 110% 60deg / 0)", "oklch(-0.1 0.44 60 / 0)", +"oklch(-10 110 60 / 0.2)", "oklch(-10 110 60 / 0.2)", +"oklch(-10% 110% 60deg / 0.2)", "oklch(-0.1 0.44 60 / 0.2)", +"oklch(-10 110 60 / 1)", "oklch(-10 110 60)", +"oklch(-10% 110% 60deg / 1)", "oklch(-0.1 0.44 60)", +"oklch(0 -10 60)", "oklch(0 -10 60)", +"oklch(0% -10% 60deg)", "oklch(0 -0.04 60)", +"oklch(0 -10 60 / 0)", "oklch(0 -10 60 / 0)", +"oklch(0% -10% 60deg / 0)", "oklch(0 -0.04 60 / 0)", +"oklch(0 -10 60 / 0.2)", "oklch(0 -10 60 / 0.2)", +"oklch(0% -10% 60deg / 0.2)", "oklch(0 -0.04 60 / 0.2)", +"oklch(0 -10 60 / 1)", "oklch(0 -10 60)", +"oklch(0% -10% 60deg / 1)", "oklch(0 -0.04 60)", +"oklch(10 -10 60)", "oklch(10 -10 60)", +"oklch(10% -10% 60deg)", "oklch(0.1 -0.04 60)", +"oklch(10 -10 60 / 0)", "oklch(10 -10 60 / 0)", +"oklch(10% -10% 60deg / 0)", "oklch(0.1 -0.04 60 / 0)", +"oklch(10 -10 60 / 0.2)", "oklch(10 -10 60 / 0.2)", +"oklch(10% -10% 60deg / 0.2)", "oklch(0.1 -0.04 60 / 0.2)", +"oklch(10 -10 60 / 1)", "oklch(10 -10 60)", +"oklch(10% -10% 60deg / 1)", "oklch(0.1 -0.04 60)", +"oklch(110 -10 60)", "oklch(110 -10 60)", +"oklch(110% -10% 60deg)", "oklch(1.1 -0.04 60)", +"oklch(110 -10 60 / 0)", "oklch(110 -10 60 / 0)", +"oklch(110% -10% 60deg / 0)", "oklch(1.1 -0.04 60 / 0)", +"oklch(110 -10 60 / 0.2)", "oklch(110 -10 60 / 0.2)", +"oklch(110% -10% 60deg / 0.2)", "oklch(1.1 -0.04 60 / 0.2)", +"oklch(110 -10 60 / 1)", "oklch(110 -10 60)", +"oklch(110% -10% 60deg / 1)", "oklch(1.1 -0.04 60)", +"oklch(-10 -10 60)", "oklch(-10 -10 60)", +"oklch(-10% -10% 60deg)", "oklch(-0.1 -0.04 60)", +"oklch(-10 -10 60 / 0)", "oklch(-10 -10 60 / 0)", +"oklch(-10% -10% 60deg / 0)", "oklch(-0.1 -0.04 60 / 0)", +"oklch(-10 -10 60 / 0.2)", "oklch(-10 -10 60 / 0.2)", +"oklch(-10% -10% 60deg / 0.2)", "oklch(-0.1 -0.04 60 / 0.2)", +"oklch(-10 -10 60 / 1)", "oklch(-10 -10 60)", +"oklch(-10% -10% 60deg / 1)", "oklch(-0.1 -0.04 60)", +"oklch(0 0 90)", "oklch(0 0 90)", +"oklch(0% 0% 90deg)", "oklch(0 0 90)", +"oklch(0 0 90 / 0)", "oklch(0 0 90 / 0)", +"oklch(0% 0% 90deg / 0)", "oklch(0 0 90 / 0)", +"oklch(0 0 90 / 0.2)", "oklch(0 0 90 / 0.2)", +"oklch(0% 0% 90deg / 0.2)", "oklch(0 0 90 / 0.2)", +"oklch(0 0 90 / 1)", "oklch(0 0 90)", +"oklch(0% 0% 90deg / 1)", "oklch(0 0 90)", +"oklch(10 0 90)", "oklch(10 0 90)", +"oklch(10% 0% 90deg)", "oklch(0.1 0 90)", +"oklch(10 0 90 / 0)", "oklch(10 0 90 / 0)", +"oklch(10% 0% 90deg / 0)", "oklch(0.1 0 90 / 0)", +"oklch(10 0 90 / 0.2)", "oklch(10 0 90 / 0.2)", +"oklch(10% 0% 90deg / 0.2)", "oklch(0.1 0 90 / 0.2)", +"oklch(10 0 90 / 1)", "oklch(10 0 90)", +"oklch(10% 0% 90deg / 1)", "oklch(0.1 0 90)", +"oklch(110 0 90)", "oklch(110 0 90)", +"oklch(110% 0% 90deg)", "oklch(1.1 0 90)", +"oklch(110 0 90 / 0)", "oklch(110 0 90 / 0)", +"oklch(110% 0% 90deg / 0)", "oklch(1.1 0 90 / 0)", +"oklch(110 0 90 / 0.2)", "oklch(110 0 90 / 0.2)", +"oklch(110% 0% 90deg / 0.2)", "oklch(1.1 0 90 / 0.2)", +"oklch(110 0 90 / 1)", "oklch(110 0 90)", +"oklch(110% 0% 90deg / 1)", "oklch(1.1 0 90)", +"oklch(-10 0 90)", "oklch(-10 0 90)", +"oklch(-10% 0% 90deg)", "oklch(-0.1 0 90)", +"oklch(-10 0 90 / 0)", "oklch(-10 0 90 / 0)", +"oklch(-10% 0% 90deg / 0)", "oklch(-0.1 0 90 / 0)", +"oklch(-10 0 90 / 0.2)", "oklch(-10 0 90 / 0.2)", +"oklch(-10% 0% 90deg / 0.2)", "oklch(-0.1 0 90 / 0.2)", +"oklch(-10 0 90 / 1)", "oklch(-10 0 90)", +"oklch(-10% 0% 90deg / 1)", "oklch(-0.1 0 90)", +"oklch(0 10 90)", "oklch(0 10 90)", +"oklch(0% 10% 90deg)", "oklch(0 0.04 90)", +"oklch(0 10 90 / 0)", "oklch(0 10 90 / 0)", +"oklch(0% 10% 90deg / 0)", "oklch(0 0.04 90 / 0)", +"oklch(0 10 90 / 0.2)", "oklch(0 10 90 / 0.2)", +"oklch(0% 10% 90deg / 0.2)", "oklch(0 0.04 90 / 0.2)", +"oklch(0 10 90 / 1)", "oklch(0 10 90)", +"oklch(0% 10% 90deg / 1)", "oklch(0 0.04 90)", +"oklch(10 10 90)", "oklch(10 10 90)", +"oklch(10% 10% 90deg)", "oklch(0.1 0.04 90)", +"oklch(10 10 90 / 0)", "oklch(10 10 90 / 0)", +"oklch(10% 10% 90deg / 0)", "oklch(0.1 0.04 90 / 0)", +"oklch(10 10 90 / 0.2)", "oklch(10 10 90 / 0.2)", +"oklch(10% 10% 90deg / 0.2)", "oklch(0.1 0.04 90 / 0.2)", +"oklch(10 10 90 / 1)", "oklch(10 10 90)", +"oklch(10% 10% 90deg / 1)", "oklch(0.1 0.04 90)", +"oklch(110 10 90)", "oklch(110 10 90)", +"oklch(110% 10% 90deg)", "oklch(1.1 0.04 90)", +"oklch(110 10 90 / 0)", "oklch(110 10 90 / 0)", +"oklch(110% 10% 90deg / 0)", "oklch(1.1 0.04 90 / 0)", +"oklch(110 10 90 / 0.2)", "oklch(110 10 90 / 0.2)", +"oklch(110% 10% 90deg / 0.2)", "oklch(1.1 0.04 90 / 0.2)", +"oklch(110 10 90 / 1)", "oklch(110 10 90)", +"oklch(110% 10% 90deg / 1)", "oklch(1.1 0.04 90)", +"oklch(-10 10 90)", "oklch(-10 10 90)", +"oklch(-10% 10% 90deg)", "oklch(-0.1 0.04 90)", +"oklch(-10 10 90 / 0)", "oklch(-10 10 90 / 0)", +"oklch(-10% 10% 90deg / 0)", "oklch(-0.1 0.04 90 / 0)", +"oklch(-10 10 90 / 0.2)", "oklch(-10 10 90 / 0.2)", +"oklch(-10% 10% 90deg / 0.2)", "oklch(-0.1 0.04 90 / 0.2)", +"oklch(-10 10 90 / 1)", "oklch(-10 10 90)", +"oklch(-10% 10% 90deg / 1)", "oklch(-0.1 0.04 90)", +"oklch(0 110 90)", "oklch(0 110 90)", +"oklch(0% 110% 90deg)", "oklch(0 0.44 90)", +"oklch(0 110 90 / 0)", "oklch(0 110 90 / 0)", +"oklch(0% 110% 90deg / 0)", "oklch(0 0.44 90 / 0)", +"oklch(0 110 90 / 0.2)", "oklch(0 110 90 / 0.2)", +"oklch(0% 110% 90deg / 0.2)", "oklch(0 0.44 90 / 0.2)", +"oklch(0 110 90 / 1)", "oklch(0 110 90)", +"oklch(0% 110% 90deg / 1)", "oklch(0 0.44 90)", +"oklch(10 110 90)", "oklch(10 110 90)", +"oklch(10% 110% 90deg)", "oklch(0.1 0.44 90)", +"oklch(10 110 90 / 0)", "oklch(10 110 90 / 0)", +"oklch(10% 110% 90deg / 0)", "oklch(0.1 0.44 90 / 0)", +"oklch(10 110 90 / 0.2)", "oklch(10 110 90 / 0.2)", +"oklch(10% 110% 90deg / 0.2)", "oklch(0.1 0.44 90 / 0.2)", +"oklch(10 110 90 / 1)", "oklch(10 110 90)", +"oklch(10% 110% 90deg / 1)", "oklch(0.1 0.44 90)", +"oklch(110 110 90)", "oklch(110 110 90)", +"oklch(110% 110% 90deg)", "oklch(1.1 0.44 90)", +"oklch(110 110 90 / 0)", "oklch(110 110 90 / 0)", +"oklch(110% 110% 90deg / 0)", "oklch(1.1 0.44 90 / 0)", +"oklch(110 110 90 / 0.2)", "oklch(110 110 90 / 0.2)", +"oklch(110% 110% 90deg / 0.2)", "oklch(1.1 0.44 90 / 0.2)", +"oklch(110 110 90 / 1)", "oklch(110 110 90)", +"oklch(110% 110% 90deg / 1)", "oklch(1.1 0.44 90)", +"oklch(-10 110 90)", "oklch(-10 110 90)", +"oklch(-10% 110% 90deg)", "oklch(-0.1 0.44 90)", +"oklch(-10 110 90 / 0)", "oklch(-10 110 90 / 0)", +"oklch(-10% 110% 90deg / 0)", "oklch(-0.1 0.44 90 / 0)", +"oklch(-10 110 90 / 0.2)", "oklch(-10 110 90 / 0.2)", +"oklch(-10% 110% 90deg / 0.2)", "oklch(-0.1 0.44 90 / 0.2)", +"oklch(-10 110 90 / 1)", "oklch(-10 110 90)", +"oklch(-10% 110% 90deg / 1)", "oklch(-0.1 0.44 90)", +"oklch(0 -10 90)", "oklch(0 -10 90)", +"oklch(0% -10% 90deg)", "oklch(0 -0.04 90)", +"oklch(0 -10 90 / 0)", "oklch(0 -10 90 / 0)", +"oklch(0% -10% 90deg / 0)", "oklch(0 -0.04 90 / 0)", +"oklch(0 -10 90 / 0.2)", "oklch(0 -10 90 / 0.2)", +"oklch(0% -10% 90deg / 0.2)", "oklch(0 -0.04 90 / 0.2)", +"oklch(0 -10 90 / 1)", "oklch(0 -10 90)", +"oklch(0% -10% 90deg / 1)", "oklch(0 -0.04 90)", +"oklch(10 -10 90)", "oklch(10 -10 90)", +"oklch(10% -10% 90deg)", "oklch(0.1 -0.04 90)", +"oklch(10 -10 90 / 0)", "oklch(10 -10 90 / 0)", +"oklch(10% -10% 90deg / 0)", "oklch(0.1 -0.04 90 / 0)", +"oklch(10 -10 90 / 0.2)", "oklch(10 -10 90 / 0.2)", +"oklch(10% -10% 90deg / 0.2)", "oklch(0.1 -0.04 90 / 0.2)", +"oklch(10 -10 90 / 1)", "oklch(10 -10 90)", +"oklch(10% -10% 90deg / 1)", "oklch(0.1 -0.04 90)", +"oklch(110 -10 90)", "oklch(110 -10 90)", +"oklch(110% -10% 90deg)", "oklch(1.1 -0.04 90)", +"oklch(110 -10 90 / 0)", "oklch(110 -10 90 / 0)", +"oklch(110% -10% 90deg / 0)", "oklch(1.1 -0.04 90 / 0)", +"oklch(110 -10 90 / 0.2)", "oklch(110 -10 90 / 0.2)", +"oklch(110% -10% 90deg / 0.2)", "oklch(1.1 -0.04 90 / 0.2)", +"oklch(110 -10 90 / 1)", "oklch(110 -10 90)", +"oklch(110% -10% 90deg / 1)", "oklch(1.1 -0.04 90)", +"oklch(-10 -10 90)", "oklch(-10 -10 90)", +"oklch(-10% -10% 90deg)", "oklch(-0.1 -0.04 90)", +"oklch(-10 -10 90 / 0)", "oklch(-10 -10 90 / 0)", +"oklch(-10% -10% 90deg / 0)", "oklch(-0.1 -0.04 90 / 0)", +"oklch(-10 -10 90 / 0.2)", "oklch(-10 -10 90 / 0.2)", +"oklch(-10% -10% 90deg / 0.2)", "oklch(-0.1 -0.04 90 / 0.2)", +"oklch(-10 -10 90 / 1)", "oklch(-10 -10 90)", +"oklch(-10% -10% 90deg / 1)", "oklch(-0.1 -0.04 90)", +"oklch(0 0 120)", "oklch(0 0 120)", +"oklch(0% 0% 120deg)", "oklch(0 0 120)", +"oklch(0 0 120 / 0)", "oklch(0 0 120 / 0)", +"oklch(0% 0% 120deg / 0)", "oklch(0 0 120 / 0)", +"oklch(0 0 120 / 0.2)", "oklch(0 0 120 / 0.2)", +"oklch(0% 0% 120deg / 0.2)", "oklch(0 0 120 / 0.2)", +"oklch(0 0 120 / 1)", "oklch(0 0 120)", +"oklch(0% 0% 120deg / 1)", "oklch(0 0 120)", +"oklch(10 0 120)", "oklch(10 0 120)", +"oklch(10% 0% 120deg)", "oklch(0.1 0 120)", +"oklch(10 0 120 / 0)", "oklch(10 0 120 / 0)", +"oklch(10% 0% 120deg / 0)", "oklch(0.1 0 120 / 0)", +"oklch(10 0 120 / 0.2)", "oklch(10 0 120 / 0.2)", +"oklch(10% 0% 120deg / 0.2)", "oklch(0.1 0 120 / 0.2)", +"oklch(10 0 120 / 1)", "oklch(10 0 120)", +"oklch(10% 0% 120deg / 1)", "oklch(0.1 0 120)", +"oklch(110 0 120)", "oklch(110 0 120)", +"oklch(110% 0% 120deg)", "oklch(1.1 0 120)", +"oklch(110 0 120 / 0)", "oklch(110 0 120 / 0)", +"oklch(110% 0% 120deg / 0)", "oklch(1.1 0 120 / 0)", +"oklch(110 0 120 / 0.2)", "oklch(110 0 120 / 0.2)", +"oklch(110% 0% 120deg / 0.2)", "oklch(1.1 0 120 / 0.2)", +"oklch(110 0 120 / 1)", "oklch(110 0 120)", +"oklch(110% 0% 120deg / 1)", "oklch(1.1 0 120)", +"oklch(-10 0 120)", "oklch(-10 0 120)", +"oklch(-10% 0% 120deg)", "oklch(-0.1 0 120)", +"oklch(-10 0 120 / 0)", "oklch(-10 0 120 / 0)", +"oklch(-10% 0% 120deg / 0)", "oklch(-0.1 0 120 / 0)", +"oklch(-10 0 120 / 0.2)", "oklch(-10 0 120 / 0.2)", +"oklch(-10% 0% 120deg / 0.2)", "oklch(-0.1 0 120 / 0.2)", +"oklch(-10 0 120 / 1)", "oklch(-10 0 120)", +"oklch(-10% 0% 120deg / 1)", "oklch(-0.1 0 120)", +"oklch(0 10 120)", "oklch(0 10 120)", +"oklch(0% 10% 120deg)", "oklch(0 0.04 120)", +"oklch(0 10 120 / 0)", "oklch(0 10 120 / 0)", +"oklch(0% 10% 120deg / 0)", "oklch(0 0.04 120 / 0)", +"oklch(0 10 120 / 0.2)", "oklch(0 10 120 / 0.2)", +"oklch(0% 10% 120deg / 0.2)", "oklch(0 0.04 120 / 0.2)", +"oklch(0 10 120 / 1)", "oklch(0 10 120)", +"oklch(0% 10% 120deg / 1)", "oklch(0 0.04 120)", +"oklch(10 10 120)", "oklch(10 10 120)", +"oklch(10% 10% 120deg)", "oklch(0.1 0.04 120)", +"oklch(10 10 120 / 0)", "oklch(10 10 120 / 0)", +"oklch(10% 10% 120deg / 0)", "oklch(0.1 0.04 120 / 0)", +"oklch(10 10 120 / 0.2)", "oklch(10 10 120 / 0.2)", +"oklch(10% 10% 120deg / 0.2)", "oklch(0.1 0.04 120 / 0.2)", +"oklch(10 10 120 / 1)", "oklch(10 10 120)", +"oklch(10% 10% 120deg / 1)", "oklch(0.1 0.04 120)", +"oklch(110 10 120)", "oklch(110 10 120)", +"oklch(110% 10% 120deg)", "oklch(1.1 0.04 120)", +"oklch(110 10 120 / 0)", "oklch(110 10 120 / 0)", +"oklch(110% 10% 120deg / 0)", "oklch(1.1 0.04 120 / 0)", +"oklch(110 10 120 / 0.2)", "oklch(110 10 120 / 0.2)", +"oklch(110% 10% 120deg / 0.2)", "oklch(1.1 0.04 120 / 0.2)", +"oklch(110 10 120 / 1)", "oklch(110 10 120)", +"oklch(110% 10% 120deg / 1)", "oklch(1.1 0.04 120)", +"oklch(-10 10 120)", "oklch(-10 10 120)", +"oklch(-10% 10% 120deg)", "oklch(-0.1 0.04 120)", +"oklch(-10 10 120 / 0)", "oklch(-10 10 120 / 0)", +"oklch(-10% 10% 120deg / 0)", "oklch(-0.1 0.04 120 / 0)", +"oklch(-10 10 120 / 0.2)", "oklch(-10 10 120 / 0.2)", +"oklch(-10% 10% 120deg / 0.2)", "oklch(-0.1 0.04 120 / 0.2)", +"oklch(-10 10 120 / 1)", "oklch(-10 10 120)", +"oklch(-10% 10% 120deg / 1)", "oklch(-0.1 0.04 120)", +"oklch(0 110 120)", "oklch(0 110 120)", +"oklch(0% 110% 120deg)", "oklch(0 0.44 120)", +"oklch(0 110 120 / 0)", "oklch(0 110 120 / 0)", +"oklch(0% 110% 120deg / 0)", "oklch(0 0.44 120 / 0)", +"oklch(0 110 120 / 0.2)", "oklch(0 110 120 / 0.2)", +"oklch(0% 110% 120deg / 0.2)", "oklch(0 0.44 120 / 0.2)", +"oklch(0 110 120 / 1)", "oklch(0 110 120)", +"oklch(0% 110% 120deg / 1)", "oklch(0 0.44 120)", +"oklch(10 110 120)", "oklch(10 110 120)", +"oklch(10% 110% 120deg)", "oklch(0.1 0.44 120)", +"oklch(10 110 120 / 0)", "oklch(10 110 120 / 0)", +"oklch(10% 110% 120deg / 0)", "oklch(0.1 0.44 120 / 0)", +"oklch(10 110 120 / 0.2)", "oklch(10 110 120 / 0.2)", +"oklch(10% 110% 120deg / 0.2)", "oklch(0.1 0.44 120 / 0.2)", +"oklch(10 110 120 / 1)", "oklch(10 110 120)", +"oklch(10% 110% 120deg / 1)", "oklch(0.1 0.44 120)", +"oklch(110 110 120)", "oklch(110 110 120)", +"oklch(110% 110% 120deg)", "oklch(1.1 0.44 120)", +"oklch(110 110 120 / 0)", "oklch(110 110 120 / 0)", +"oklch(110% 110% 120deg / 0)", "oklch(1.1 0.44 120 / 0)", +"oklch(110 110 120 / 0.2)", "oklch(110 110 120 / 0.2)", +"oklch(110% 110% 120deg / 0.2)", "oklch(1.1 0.44 120 / 0.2)", +"oklch(110 110 120 / 1)", "oklch(110 110 120)", +"oklch(110% 110% 120deg / 1)", "oklch(1.1 0.44 120)", +"oklch(-10 110 120)", "oklch(-10 110 120)", +"oklch(-10% 110% 120deg)", "oklch(-0.1 0.44 120)", +"oklch(-10 110 120 / 0)", "oklch(-10 110 120 / 0)", +"oklch(-10% 110% 120deg / 0)", "oklch(-0.1 0.44 120 / 0)", +"oklch(-10 110 120 / 0.2)", "oklch(-10 110 120 / 0.2)", +"oklch(-10% 110% 120deg / 0.2)", "oklch(-0.1 0.44 120 / 0.2)", +"oklch(-10 110 120 / 1)", "oklch(-10 110 120)", +"oklch(-10% 110% 120deg / 1)", "oklch(-0.1 0.44 120)", +"oklch(0 -10 120)", "oklch(0 -10 120)", +"oklch(0% -10% 120deg)", "oklch(0 -0.04 120)", +"oklch(0 -10 120 / 0)", "oklch(0 -10 120 / 0)", +"oklch(0% -10% 120deg / 0)", "oklch(0 -0.04 120 / 0)", +"oklch(0 -10 120 / 0.2)", "oklch(0 -10 120 / 0.2)", +"oklch(0% -10% 120deg / 0.2)", "oklch(0 -0.04 120 / 0.2)", +"oklch(0 -10 120 / 1)", "oklch(0 -10 120)", +"oklch(0% -10% 120deg / 1)", "oklch(0 -0.04 120)", +"oklch(10 -10 120)", "oklch(10 -10 120)", +"oklch(10% -10% 120deg)", "oklch(0.1 -0.04 120)", +"oklch(10 -10 120 / 0)", "oklch(10 -10 120 / 0)", +"oklch(10% -10% 120deg / 0)", "oklch(0.1 -0.04 120 / 0)", +"oklch(10 -10 120 / 0.2)", "oklch(10 -10 120 / 0.2)", +"oklch(10% -10% 120deg / 0.2)", "oklch(0.1 -0.04 120 / 0.2)", +"oklch(10 -10 120 / 1)", "oklch(10 -10 120)", +"oklch(10% -10% 120deg / 1)", "oklch(0.1 -0.04 120)", +"oklch(110 -10 120)", "oklch(110 -10 120)", +"oklch(110% -10% 120deg)", "oklch(1.1 -0.04 120)", +"oklch(110 -10 120 / 0)", "oklch(110 -10 120 / 0)", +"oklch(110% -10% 120deg / 0)", "oklch(1.1 -0.04 120 / 0)", +"oklch(110 -10 120 / 0.2)", "oklch(110 -10 120 / 0.2)", +"oklch(110% -10% 120deg / 0.2)", "oklch(1.1 -0.04 120 / 0.2)", +"oklch(110 -10 120 / 1)", "oklch(110 -10 120)", +"oklch(110% -10% 120deg / 1)", "oklch(1.1 -0.04 120)", +"oklch(-10 -10 120)", "oklch(-10 -10 120)", +"oklch(-10% -10% 120deg)", "oklch(-0.1 -0.04 120)", +"oklch(-10 -10 120 / 0)", "oklch(-10 -10 120 / 0)", +"oklch(-10% -10% 120deg / 0)", "oklch(-0.1 -0.04 120 / 0)", +"oklch(-10 -10 120 / 0.2)", "oklch(-10 -10 120 / 0.2)", +"oklch(-10% -10% 120deg / 0.2)", "oklch(-0.1 -0.04 120 / 0.2)", +"oklch(-10 -10 120 / 1)", "oklch(-10 -10 120)", +"oklch(-10% -10% 120deg / 1)", "oklch(-0.1 -0.04 120)", +"oklch(0 0 180)", "oklch(0 0 180)", +"oklch(0% 0% 180deg)", "oklch(0 0 180)", +"oklch(0 0 180 / 0)", "oklch(0 0 180 / 0)", +"oklch(0% 0% 180deg / 0)", "oklch(0 0 180 / 0)", +"oklch(0 0 180 / 0.2)", "oklch(0 0 180 / 0.2)", +"oklch(0% 0% 180deg / 0.2)", "oklch(0 0 180 / 0.2)", +"oklch(0 0 180 / 1)", "oklch(0 0 180)", +"oklch(0% 0% 180deg / 1)", "oklch(0 0 180)", +"oklch(10 0 180)", "oklch(10 0 180)", +"oklch(10% 0% 180deg)", "oklch(0.1 0 180)", +"oklch(10 0 180 / 0)", "oklch(10 0 180 / 0)", +"oklch(10% 0% 180deg / 0)", "oklch(0.1 0 180 / 0)", +"oklch(10 0 180 / 0.2)", "oklch(10 0 180 / 0.2)", +"oklch(10% 0% 180deg / 0.2)", "oklch(0.1 0 180 / 0.2)", +"oklch(10 0 180 / 1)", "oklch(10 0 180)", +"oklch(10% 0% 180deg / 1)", "oklch(0.1 0 180)", +"oklch(110 0 180)", "oklch(110 0 180)", +"oklch(110% 0% 180deg)", "oklch(1.1 0 180)", +"oklch(110 0 180 / 0)", "oklch(110 0 180 / 0)", +"oklch(110% 0% 180deg / 0)", "oklch(1.1 0 180 / 0)", +"oklch(110 0 180 / 0.2)", "oklch(110 0 180 / 0.2)", +"oklch(110% 0% 180deg / 0.2)", "oklch(1.1 0 180 / 0.2)", +"oklch(110 0 180 / 1)", "oklch(110 0 180)", +"oklch(110% 0% 180deg / 1)", "oklch(1.1 0 180)", +"oklch(-10 0 180)", "oklch(-10 0 180)", +"oklch(-10% 0% 180deg)", "oklch(-0.1 0 180)", +"oklch(-10 0 180 / 0)", "oklch(-10 0 180 / 0)", +"oklch(-10% 0% 180deg / 0)", "oklch(-0.1 0 180 / 0)", +"oklch(-10 0 180 / 0.2)", "oklch(-10 0 180 / 0.2)", +"oklch(-10% 0% 180deg / 0.2)", "oklch(-0.1 0 180 / 0.2)", +"oklch(-10 0 180 / 1)", "oklch(-10 0 180)", +"oklch(-10% 0% 180deg / 1)", "oklch(-0.1 0 180)", +"oklch(0 10 180)", "oklch(0 10 180)", +"oklch(0% 10% 180deg)", "oklch(0 0.04 180)", +"oklch(0 10 180 / 0)", "oklch(0 10 180 / 0)", +"oklch(0% 10% 180deg / 0)", "oklch(0 0.04 180 / 0)", +"oklch(0 10 180 / 0.2)", "oklch(0 10 180 / 0.2)", +"oklch(0% 10% 180deg / 0.2)", "oklch(0 0.04 180 / 0.2)", +"oklch(0 10 180 / 1)", "oklch(0 10 180)", +"oklch(0% 10% 180deg / 1)", "oklch(0 0.04 180)", +"oklch(10 10 180)", "oklch(10 10 180)", +"oklch(10% 10% 180deg)", "oklch(0.1 0.04 180)", +"oklch(10 10 180 / 0)", "oklch(10 10 180 / 0)", +"oklch(10% 10% 180deg / 0)", "oklch(0.1 0.04 180 / 0)", +"oklch(10 10 180 / 0.2)", "oklch(10 10 180 / 0.2)", +"oklch(10% 10% 180deg / 0.2)", "oklch(0.1 0.04 180 / 0.2)", +"oklch(10 10 180 / 1)", "oklch(10 10 180)", +"oklch(10% 10% 180deg / 1)", "oklch(0.1 0.04 180)", +"oklch(110 10 180)", "oklch(110 10 180)", +"oklch(110% 10% 180deg)", "oklch(1.1 0.04 180)", +"oklch(110 10 180 / 0)", "oklch(110 10 180 / 0)", +"oklch(110% 10% 180deg / 0)", "oklch(1.1 0.04 180 / 0)", +"oklch(110 10 180 / 0.2)", "oklch(110 10 180 / 0.2)", +"oklch(110% 10% 180deg / 0.2)", "oklch(1.1 0.04 180 / 0.2)", +"oklch(110 10 180 / 1)", "oklch(110 10 180)", +"oklch(110% 10% 180deg / 1)", "oklch(1.1 0.04 180)", +"oklch(-10 10 180)", "oklch(-10 10 180)", +"oklch(-10% 10% 180deg)", "oklch(-0.1 0.04 180)", +"oklch(-10 10 180 / 0)", "oklch(-10 10 180 / 0)", +"oklch(-10% 10% 180deg / 0)", "oklch(-0.1 0.04 180 / 0)", +"oklch(-10 10 180 / 0.2)", "oklch(-10 10 180 / 0.2)", +"oklch(-10% 10% 180deg / 0.2)", "oklch(-0.1 0.04 180 / 0.2)", +"oklch(-10 10 180 / 1)", "oklch(-10 10 180)", +"oklch(-10% 10% 180deg / 1)", "oklch(-0.1 0.04 180)", +"oklch(0 110 180)", "oklch(0 110 180)", +"oklch(0% 110% 180deg)", "oklch(0 0.44 180)", +"oklch(0 110 180 / 0)", "oklch(0 110 180 / 0)", +"oklch(0% 110% 180deg / 0)", "oklch(0 0.44 180 / 0)", +"oklch(0 110 180 / 0.2)", "oklch(0 110 180 / 0.2)", +"oklch(0% 110% 180deg / 0.2)", "oklch(0 0.44 180 / 0.2)", +"oklch(0 110 180 / 1)", "oklch(0 110 180)", +"oklch(0% 110% 180deg / 1)", "oklch(0 0.44 180)", +"oklch(10 110 180)", "oklch(10 110 180)", +"oklch(10% 110% 180deg)", "oklch(0.1 0.44 180)", +"oklch(10 110 180 / 0)", "oklch(10 110 180 / 0)", +"oklch(10% 110% 180deg / 0)", "oklch(0.1 0.44 180 / 0)", +"oklch(10 110 180 / 0.2)", "oklch(10 110 180 / 0.2)", +"oklch(10% 110% 180deg / 0.2)", "oklch(0.1 0.44 180 / 0.2)", +"oklch(10 110 180 / 1)", "oklch(10 110 180)", +"oklch(10% 110% 180deg / 1)", "oklch(0.1 0.44 180)", +"oklch(110 110 180)", "oklch(110 110 180)", +"oklch(110% 110% 180deg)", "oklch(1.1 0.44 180)", +"oklch(110 110 180 / 0)", "oklch(110 110 180 / 0)", +"oklch(110% 110% 180deg / 0)", "oklch(1.1 0.44 180 / 0)", +"oklch(110 110 180 / 0.2)", "oklch(110 110 180 / 0.2)", +"oklch(110% 110% 180deg / 0.2)", "oklch(1.1 0.44 180 / 0.2)", +"oklch(110 110 180 / 1)", "oklch(110 110 180)", +"oklch(110% 110% 180deg / 1)", "oklch(1.1 0.44 180)", +"oklch(-10 110 180)", "oklch(-10 110 180)", +"oklch(-10% 110% 180deg)", "oklch(-0.1 0.44 180)", +"oklch(-10 110 180 / 0)", "oklch(-10 110 180 / 0)", +"oklch(-10% 110% 180deg / 0)", "oklch(-0.1 0.44 180 / 0)", +"oklch(-10 110 180 / 0.2)", "oklch(-10 110 180 / 0.2)", +"oklch(-10% 110% 180deg / 0.2)", "oklch(-0.1 0.44 180 / 0.2)", +"oklch(-10 110 180 / 1)", "oklch(-10 110 180)", +"oklch(-10% 110% 180deg / 1)", "oklch(-0.1 0.44 180)", +"oklch(0 -10 180)", "oklch(0 -10 180)", +"oklch(0% -10% 180deg)", "oklch(0 -0.04 180)", +"oklch(0 -10 180 / 0)", "oklch(0 -10 180 / 0)", +"oklch(0% -10% 180deg / 0)", "oklch(0 -0.04 180 / 0)", +"oklch(0 -10 180 / 0.2)", "oklch(0 -10 180 / 0.2)", +"oklch(0% -10% 180deg / 0.2)", "oklch(0 -0.04 180 / 0.2)", +"oklch(0 -10 180 / 1)", "oklch(0 -10 180)", +"oklch(0% -10% 180deg / 1)", "oklch(0 -0.04 180)", +"oklch(10 -10 180)", "oklch(10 -10 180)", +"oklch(10% -10% 180deg)", "oklch(0.1 -0.04 180)", +"oklch(10 -10 180 / 0)", "oklch(10 -10 180 / 0)", +"oklch(10% -10% 180deg / 0)", "oklch(0.1 -0.04 180 / 0)", +"oklch(10 -10 180 / 0.2)", "oklch(10 -10 180 / 0.2)", +"oklch(10% -10% 180deg / 0.2)", "oklch(0.1 -0.04 180 / 0.2)", +"oklch(10 -10 180 / 1)", "oklch(10 -10 180)", +"oklch(10% -10% 180deg / 1)", "oklch(0.1 -0.04 180)", +"oklch(110 -10 180)", "oklch(110 -10 180)", +"oklch(110% -10% 180deg)", "oklch(1.1 -0.04 180)", +"oklch(110 -10 180 / 0)", "oklch(110 -10 180 / 0)", +"oklch(110% -10% 180deg / 0)", "oklch(1.1 -0.04 180 / 0)", +"oklch(110 -10 180 / 0.2)", "oklch(110 -10 180 / 0.2)", +"oklch(110% -10% 180deg / 0.2)", "oklch(1.1 -0.04 180 / 0.2)", +"oklch(110 -10 180 / 1)", "oklch(110 -10 180)", +"oklch(110% -10% 180deg / 1)", "oklch(1.1 -0.04 180)", +"oklch(-10 -10 180)", "oklch(-10 -10 180)", +"oklch(-10% -10% 180deg)", "oklch(-0.1 -0.04 180)", +"oklch(-10 -10 180 / 0)", "oklch(-10 -10 180 / 0)", +"oklch(-10% -10% 180deg / 0)", "oklch(-0.1 -0.04 180 / 0)", +"oklch(-10 -10 180 / 0.2)", "oklch(-10 -10 180 / 0.2)", +"oklch(-10% -10% 180deg / 0.2)", "oklch(-0.1 -0.04 180 / 0.2)", +"oklch(-10 -10 180 / 1)", "oklch(-10 -10 180)", +"oklch(-10% -10% 180deg / 1)", "oklch(-0.1 -0.04 180)", +"oklch(0 0 210)", "oklch(0 0 210)", +"oklch(0% 0% 210deg)", "oklch(0 0 210)", +"oklch(0 0 210 / 0)", "oklch(0 0 210 / 0)", +"oklch(0% 0% 210deg / 0)", "oklch(0 0 210 / 0)", +"oklch(0 0 210 / 0.2)", "oklch(0 0 210 / 0.2)", +"oklch(0% 0% 210deg / 0.2)", "oklch(0 0 210 / 0.2)", +"oklch(0 0 210 / 1)", "oklch(0 0 210)", +"oklch(0% 0% 210deg / 1)", "oklch(0 0 210)", +"oklch(10 0 210)", "oklch(10 0 210)", +"oklch(10% 0% 210deg)", "oklch(0.1 0 210)", +"oklch(10 0 210 / 0)", "oklch(10 0 210 / 0)", +"oklch(10% 0% 210deg / 0)", "oklch(0.1 0 210 / 0)", +"oklch(10 0 210 / 0.2)", "oklch(10 0 210 / 0.2)", +"oklch(10% 0% 210deg / 0.2)", "oklch(0.1 0 210 / 0.2)", +"oklch(10 0 210 / 1)", "oklch(10 0 210)", +"oklch(10% 0% 210deg / 1)", "oklch(0.1 0 210)", +"oklch(110 0 210)", "oklch(110 0 210)", +"oklch(110% 0% 210deg)", "oklch(1.1 0 210)", +"oklch(110 0 210 / 0)", "oklch(110 0 210 / 0)", +"oklch(110% 0% 210deg / 0)", "oklch(1.1 0 210 / 0)", +"oklch(110 0 210 / 0.2)", "oklch(110 0 210 / 0.2)", +"oklch(110% 0% 210deg / 0.2)", "oklch(1.1 0 210 / 0.2)", +"oklch(110 0 210 / 1)", "oklch(110 0 210)", +"oklch(110% 0% 210deg / 1)", "oklch(1.1 0 210)", +"oklch(-10 0 210)", "oklch(-10 0 210)", +"oklch(-10% 0% 210deg)", "oklch(-0.1 0 210)", +"oklch(-10 0 210 / 0)", "oklch(-10 0 210 / 0)", +"oklch(-10% 0% 210deg / 0)", "oklch(-0.1 0 210 / 0)", +"oklch(-10 0 210 / 0.2)", "oklch(-10 0 210 / 0.2)", +"oklch(-10% 0% 210deg / 0.2)", "oklch(-0.1 0 210 / 0.2)", +"oklch(-10 0 210 / 1)", "oklch(-10 0 210)", +"oklch(-10% 0% 210deg / 1)", "oklch(-0.1 0 210)", +"oklch(0 10 210)", "oklch(0 10 210)", +"oklch(0% 10% 210deg)", "oklch(0 0.04 210)", +"oklch(0 10 210 / 0)", "oklch(0 10 210 / 0)", +"oklch(0% 10% 210deg / 0)", "oklch(0 0.04 210 / 0)", +"oklch(0 10 210 / 0.2)", "oklch(0 10 210 / 0.2)", +"oklch(0% 10% 210deg / 0.2)", "oklch(0 0.04 210 / 0.2)", +"oklch(0 10 210 / 1)", "oklch(0 10 210)", +"oklch(0% 10% 210deg / 1)", "oklch(0 0.04 210)", +"oklch(10 10 210)", "oklch(10 10 210)", +"oklch(10% 10% 210deg)", "oklch(0.1 0.04 210)", +"oklch(10 10 210 / 0)", "oklch(10 10 210 / 0)", +"oklch(10% 10% 210deg / 0)", "oklch(0.1 0.04 210 / 0)", +"oklch(10 10 210 / 0.2)", "oklch(10 10 210 / 0.2)", +"oklch(10% 10% 210deg / 0.2)", "oklch(0.1 0.04 210 / 0.2)", +"oklch(10 10 210 / 1)", "oklch(10 10 210)", +"oklch(10% 10% 210deg / 1)", "oklch(0.1 0.04 210)", +"oklch(110 10 210)", "oklch(110 10 210)", +"oklch(110% 10% 210deg)", "oklch(1.1 0.04 210)", +"oklch(110 10 210 / 0)", "oklch(110 10 210 / 0)", +"oklch(110% 10% 210deg / 0)", "oklch(1.1 0.04 210 / 0)", +"oklch(110 10 210 / 0.2)", "oklch(110 10 210 / 0.2)", +"oklch(110% 10% 210deg / 0.2)", "oklch(1.1 0.04 210 / 0.2)", +"oklch(110 10 210 / 1)", "oklch(110 10 210)", +"oklch(110% 10% 210deg / 1)", "oklch(1.1 0.04 210)", +"oklch(-10 10 210)", "oklch(-10 10 210)", +"oklch(-10% 10% 210deg)", "oklch(-0.1 0.04 210)", +"oklch(-10 10 210 / 0)", "oklch(-10 10 210 / 0)", +"oklch(-10% 10% 210deg / 0)", "oklch(-0.1 0.04 210 / 0)", +"oklch(-10 10 210 / 0.2)", "oklch(-10 10 210 / 0.2)", +"oklch(-10% 10% 210deg / 0.2)", "oklch(-0.1 0.04 210 / 0.2)", +"oklch(-10 10 210 / 1)", "oklch(-10 10 210)", +"oklch(-10% 10% 210deg / 1)", "oklch(-0.1 0.04 210)", +"oklch(0 110 210)", "oklch(0 110 210)", +"oklch(0% 110% 210deg)", "oklch(0 0.44 210)", +"oklch(0 110 210 / 0)", "oklch(0 110 210 / 0)", +"oklch(0% 110% 210deg / 0)", "oklch(0 0.44 210 / 0)", +"oklch(0 110 210 / 0.2)", "oklch(0 110 210 / 0.2)", +"oklch(0% 110% 210deg / 0.2)", "oklch(0 0.44 210 / 0.2)", +"oklch(0 110 210 / 1)", "oklch(0 110 210)", +"oklch(0% 110% 210deg / 1)", "oklch(0 0.44 210)", +"oklch(10 110 210)", "oklch(10 110 210)", +"oklch(10% 110% 210deg)", "oklch(0.1 0.44 210)", +"oklch(10 110 210 / 0)", "oklch(10 110 210 / 0)", +"oklch(10% 110% 210deg / 0)", "oklch(0.1 0.44 210 / 0)", +"oklch(10 110 210 / 0.2)", "oklch(10 110 210 / 0.2)", +"oklch(10% 110% 210deg / 0.2)", "oklch(0.1 0.44 210 / 0.2)", +"oklch(10 110 210 / 1)", "oklch(10 110 210)", +"oklch(10% 110% 210deg / 1)", "oklch(0.1 0.44 210)", +"oklch(110 110 210)", "oklch(110 110 210)", +"oklch(110% 110% 210deg)", "oklch(1.1 0.44 210)", +"oklch(110 110 210 / 0)", "oklch(110 110 210 / 0)", +"oklch(110% 110% 210deg / 0)", "oklch(1.1 0.44 210 / 0)", +"oklch(110 110 210 / 0.2)", "oklch(110 110 210 / 0.2)", +"oklch(110% 110% 210deg / 0.2)", "oklch(1.1 0.44 210 / 0.2)", +"oklch(110 110 210 / 1)", "oklch(110 110 210)", +"oklch(110% 110% 210deg / 1)", "oklch(1.1 0.44 210)", +"oklch(-10 110 210)", "oklch(-10 110 210)", +"oklch(-10% 110% 210deg)", "oklch(-0.1 0.44 210)", +"oklch(-10 110 210 / 0)", "oklch(-10 110 210 / 0)", +"oklch(-10% 110% 210deg / 0)", "oklch(-0.1 0.44 210 / 0)", +"oklch(-10 110 210 / 0.2)", "oklch(-10 110 210 / 0.2)", +"oklch(-10% 110% 210deg / 0.2)", "oklch(-0.1 0.44 210 / 0.2)", +"oklch(-10 110 210 / 1)", "oklch(-10 110 210)", +"oklch(-10% 110% 210deg / 1)", "oklch(-0.1 0.44 210)", +"oklch(0 -10 210)", "oklch(0 -10 210)", +"oklch(0% -10% 210deg)", "oklch(0 -0.04 210)", +"oklch(0 -10 210 / 0)", "oklch(0 -10 210 / 0)", +"oklch(0% -10% 210deg / 0)", "oklch(0 -0.04 210 / 0)", +"oklch(0 -10 210 / 0.2)", "oklch(0 -10 210 / 0.2)", +"oklch(0% -10% 210deg / 0.2)", "oklch(0 -0.04 210 / 0.2)", +"oklch(0 -10 210 / 1)", "oklch(0 -10 210)", +"oklch(0% -10% 210deg / 1)", "oklch(0 -0.04 210)", +"oklch(10 -10 210)", "oklch(10 -10 210)", +"oklch(10% -10% 210deg)", "oklch(0.1 -0.04 210)", +"oklch(10 -10 210 / 0)", "oklch(10 -10 210 / 0)", +"oklch(10% -10% 210deg / 0)", "oklch(0.1 -0.04 210 / 0)", +"oklch(10 -10 210 / 0.2)", "oklch(10 -10 210 / 0.2)", +"oklch(10% -10% 210deg / 0.2)", "oklch(0.1 -0.04 210 / 0.2)", +"oklch(10 -10 210 / 1)", "oklch(10 -10 210)", +"oklch(10% -10% 210deg / 1)", "oklch(0.1 -0.04 210)", +"oklch(110 -10 210)", "oklch(110 -10 210)", +"oklch(110% -10% 210deg)", "oklch(1.1 -0.04 210)", +"oklch(110 -10 210 / 0)", "oklch(110 -10 210 / 0)", +"oklch(110% -10% 210deg / 0)", "oklch(1.1 -0.04 210 / 0)", +"oklch(110 -10 210 / 0.2)", "oklch(110 -10 210 / 0.2)", +"oklch(110% -10% 210deg / 0.2)", "oklch(1.1 -0.04 210 / 0.2)", +"oklch(110 -10 210 / 1)", "oklch(110 -10 210)", +"oklch(110% -10% 210deg / 1)", "oklch(1.1 -0.04 210)", +"oklch(-10 -10 210)", "oklch(-10 -10 210)", +"oklch(-10% -10% 210deg)", "oklch(-0.1 -0.04 210)", +"oklch(-10 -10 210 / 0)", "oklch(-10 -10 210 / 0)", +"oklch(-10% -10% 210deg / 0)", "oklch(-0.1 -0.04 210 / 0)", +"oklch(-10 -10 210 / 0.2)", "oklch(-10 -10 210 / 0.2)", +"oklch(-10% -10% 210deg / 0.2)", "oklch(-0.1 -0.04 210 / 0.2)", +"oklch(-10 -10 210 / 1)", "oklch(-10 -10 210)", +"oklch(-10% -10% 210deg / 1)", "oklch(-0.1 -0.04 210)", +"oklch(0 0 240)", "oklch(0 0 240)", +"oklch(0% 0% 240deg)", "oklch(0 0 240)", +"oklch(0 0 240 / 0)", "oklch(0 0 240 / 0)", +"oklch(0% 0% 240deg / 0)", "oklch(0 0 240 / 0)", +"oklch(0 0 240 / 0.2)", "oklch(0 0 240 / 0.2)", +"oklch(0% 0% 240deg / 0.2)", "oklch(0 0 240 / 0.2)", +"oklch(0 0 240 / 1)", "oklch(0 0 240)", +"oklch(0% 0% 240deg / 1)", "oklch(0 0 240)", +"oklch(10 0 240)", "oklch(10 0 240)", +"oklch(10% 0% 240deg)", "oklch(0.1 0 240)", +"oklch(10 0 240 / 0)", "oklch(10 0 240 / 0)", +"oklch(10% 0% 240deg / 0)", "oklch(0.1 0 240 / 0)", +"oklch(10 0 240 / 0.2)", "oklch(10 0 240 / 0.2)", +"oklch(10% 0% 240deg / 0.2)", "oklch(0.1 0 240 / 0.2)", +"oklch(10 0 240 / 1)", "oklch(10 0 240)", +"oklch(10% 0% 240deg / 1)", "oklch(0.1 0 240)", +"oklch(110 0 240)", "oklch(110 0 240)", +"oklch(110% 0% 240deg)", "oklch(1.1 0 240)", +"oklch(110 0 240 / 0)", "oklch(110 0 240 / 0)", +"oklch(110% 0% 240deg / 0)", "oklch(1.1 0 240 / 0)", +"oklch(110 0 240 / 0.2)", "oklch(110 0 240 / 0.2)", +"oklch(110% 0% 240deg / 0.2)", "oklch(1.1 0 240 / 0.2)", +"oklch(110 0 240 / 1)", "oklch(110 0 240)", +"oklch(110% 0% 240deg / 1)", "oklch(1.1 0 240)", +"oklch(-10 0 240)", "oklch(-10 0 240)", +"oklch(-10% 0% 240deg)", "oklch(-0.1 0 240)", +"oklch(-10 0 240 / 0)", "oklch(-10 0 240 / 0)", +"oklch(-10% 0% 240deg / 0)", "oklch(-0.1 0 240 / 0)", +"oklch(-10 0 240 / 0.2)", "oklch(-10 0 240 / 0.2)", +"oklch(-10% 0% 240deg / 0.2)", "oklch(-0.1 0 240 / 0.2)", +"oklch(-10 0 240 / 1)", "oklch(-10 0 240)", +"oklch(-10% 0% 240deg / 1)", "oklch(-0.1 0 240)", +"oklch(0 10 240)", "oklch(0 10 240)", +"oklch(0% 10% 240deg)", "oklch(0 0.04 240)", +"oklch(0 10 240 / 0)", "oklch(0 10 240 / 0)", +"oklch(0% 10% 240deg / 0)", "oklch(0 0.04 240 / 0)", +"oklch(0 10 240 / 0.2)", "oklch(0 10 240 / 0.2)", +"oklch(0% 10% 240deg / 0.2)", "oklch(0 0.04 240 / 0.2)", +"oklch(0 10 240 / 1)", "oklch(0 10 240)", +"oklch(0% 10% 240deg / 1)", "oklch(0 0.04 240)", +"oklch(10 10 240)", "oklch(10 10 240)", +"oklch(10% 10% 240deg)", "oklch(0.1 0.04 240)", +"oklch(10 10 240 / 0)", "oklch(10 10 240 / 0)", +"oklch(10% 10% 240deg / 0)", "oklch(0.1 0.04 240 / 0)", +"oklch(10 10 240 / 0.2)", "oklch(10 10 240 / 0.2)", +"oklch(10% 10% 240deg / 0.2)", "oklch(0.1 0.04 240 / 0.2)", +"oklch(10 10 240 / 1)", "oklch(10 10 240)", +"oklch(10% 10% 240deg / 1)", "oklch(0.1 0.04 240)", +"oklch(110 10 240)", "oklch(110 10 240)", +"oklch(110% 10% 240deg)", "oklch(1.1 0.04 240)", +"oklch(110 10 240 / 0)", "oklch(110 10 240 / 0)", +"oklch(110% 10% 240deg / 0)", "oklch(1.1 0.04 240 / 0)", +"oklch(110 10 240 / 0.2)", "oklch(110 10 240 / 0.2)", +"oklch(110% 10% 240deg / 0.2)", "oklch(1.1 0.04 240 / 0.2)", +"oklch(110 10 240 / 1)", "oklch(110 10 240)", +"oklch(110% 10% 240deg / 1)", "oklch(1.1 0.04 240)", +"oklch(-10 10 240)", "oklch(-10 10 240)", +"oklch(-10% 10% 240deg)", "oklch(-0.1 0.04 240)", +"oklch(-10 10 240 / 0)", "oklch(-10 10 240 / 0)", +"oklch(-10% 10% 240deg / 0)", "oklch(-0.1 0.04 240 / 0)", +"oklch(-10 10 240 / 0.2)", "oklch(-10 10 240 / 0.2)", +"oklch(-10% 10% 240deg / 0.2)", "oklch(-0.1 0.04 240 / 0.2)", +"oklch(-10 10 240 / 1)", "oklch(-10 10 240)", +"oklch(-10% 10% 240deg / 1)", "oklch(-0.1 0.04 240)", +"oklch(0 110 240)", "oklch(0 110 240)", +"oklch(0% 110% 240deg)", "oklch(0 0.44 240)", +"oklch(0 110 240 / 0)", "oklch(0 110 240 / 0)", +"oklch(0% 110% 240deg / 0)", "oklch(0 0.44 240 / 0)", +"oklch(0 110 240 / 0.2)", "oklch(0 110 240 / 0.2)", +"oklch(0% 110% 240deg / 0.2)", "oklch(0 0.44 240 / 0.2)", +"oklch(0 110 240 / 1)", "oklch(0 110 240)", +"oklch(0% 110% 240deg / 1)", "oklch(0 0.44 240)", +"oklch(10 110 240)", "oklch(10 110 240)", +"oklch(10% 110% 240deg)", "oklch(0.1 0.44 240)", +"oklch(10 110 240 / 0)", "oklch(10 110 240 / 0)", +"oklch(10% 110% 240deg / 0)", "oklch(0.1 0.44 240 / 0)", +"oklch(10 110 240 / 0.2)", "oklch(10 110 240 / 0.2)", +"oklch(10% 110% 240deg / 0.2)", "oklch(0.1 0.44 240 / 0.2)", +"oklch(10 110 240 / 1)", "oklch(10 110 240)", +"oklch(10% 110% 240deg / 1)", "oklch(0.1 0.44 240)", +"oklch(110 110 240)", "oklch(110 110 240)", +"oklch(110% 110% 240deg)", "oklch(1.1 0.44 240)", +"oklch(110 110 240 / 0)", "oklch(110 110 240 / 0)", +"oklch(110% 110% 240deg / 0)", "oklch(1.1 0.44 240 / 0)", +"oklch(110 110 240 / 0.2)", "oklch(110 110 240 / 0.2)", +"oklch(110% 110% 240deg / 0.2)", "oklch(1.1 0.44 240 / 0.2)", +"oklch(110 110 240 / 1)", "oklch(110 110 240)", +"oklch(110% 110% 240deg / 1)", "oklch(1.1 0.44 240)", +"oklch(-10 110 240)", "oklch(-10 110 240)", +"oklch(-10% 110% 240deg)", "oklch(-0.1 0.44 240)", +"oklch(-10 110 240 / 0)", "oklch(-10 110 240 / 0)", +"oklch(-10% 110% 240deg / 0)", "oklch(-0.1 0.44 240 / 0)", +"oklch(-10 110 240 / 0.2)", "oklch(-10 110 240 / 0.2)", +"oklch(-10% 110% 240deg / 0.2)", "oklch(-0.1 0.44 240 / 0.2)", +"oklch(-10 110 240 / 1)", "oklch(-10 110 240)", +"oklch(-10% 110% 240deg / 1)", "oklch(-0.1 0.44 240)", +"oklch(0 -10 240)", "oklch(0 -10 240)", +"oklch(0% -10% 240deg)", "oklch(0 -0.04 240)", +"oklch(0 -10 240 / 0)", "oklch(0 -10 240 / 0)", +"oklch(0% -10% 240deg / 0)", "oklch(0 -0.04 240 / 0)", +"oklch(0 -10 240 / 0.2)", "oklch(0 -10 240 / 0.2)", +"oklch(0% -10% 240deg / 0.2)", "oklch(0 -0.04 240 / 0.2)", +"oklch(0 -10 240 / 1)", "oklch(0 -10 240)", +"oklch(0% -10% 240deg / 1)", "oklch(0 -0.04 240)", +"oklch(10 -10 240)", "oklch(10 -10 240)", +"oklch(10% -10% 240deg)", "oklch(0.1 -0.04 240)", +"oklch(10 -10 240 / 0)", "oklch(10 -10 240 / 0)", +"oklch(10% -10% 240deg / 0)", "oklch(0.1 -0.04 240 / 0)", +"oklch(10 -10 240 / 0.2)", "oklch(10 -10 240 / 0.2)", +"oklch(10% -10% 240deg / 0.2)", "oklch(0.1 -0.04 240 / 0.2)", +"oklch(10 -10 240 / 1)", "oklch(10 -10 240)", +"oklch(10% -10% 240deg / 1)", "oklch(0.1 -0.04 240)", +"oklch(110 -10 240)", "oklch(110 -10 240)", +"oklch(110% -10% 240deg)", "oklch(1.1 -0.04 240)", +"oklch(110 -10 240 / 0)", "oklch(110 -10 240 / 0)", +"oklch(110% -10% 240deg / 0)", "oklch(1.1 -0.04 240 / 0)", +"oklch(110 -10 240 / 0.2)", "oklch(110 -10 240 / 0.2)", +"oklch(110% -10% 240deg / 0.2)", "oklch(1.1 -0.04 240 / 0.2)", +"oklch(110 -10 240 / 1)", "oklch(110 -10 240)", +"oklch(110% -10% 240deg / 1)", "oklch(1.1 -0.04 240)", +"oklch(-10 -10 240)", "oklch(-10 -10 240)", +"oklch(-10% -10% 240deg)", "oklch(-0.1 -0.04 240)", +"oklch(-10 -10 240 / 0)", "oklch(-10 -10 240 / 0)", +"oklch(-10% -10% 240deg / 0)", "oklch(-0.1 -0.04 240 / 0)", +"oklch(-10 -10 240 / 0.2)", "oklch(-10 -10 240 / 0.2)", +"oklch(-10% -10% 240deg / 0.2)", "oklch(-0.1 -0.04 240 / 0.2)", +"oklch(-10 -10 240 / 1)", "oklch(-10 -10 240)", +"oklch(-10% -10% 240deg / 1)", "oklch(-0.1 -0.04 240)", +"oklch(0 0 270)", "oklch(0 0 270)", +"oklch(0% 0% 270deg)", "oklch(0 0 270)", +"oklch(0 0 270 / 0)", "oklch(0 0 270 / 0)", +"oklch(0% 0% 270deg / 0)", "oklch(0 0 270 / 0)", +"oklch(0 0 270 / 0.2)", "oklch(0 0 270 / 0.2)", +"oklch(0% 0% 270deg / 0.2)", "oklch(0 0 270 / 0.2)", +"oklch(0 0 270 / 1)", "oklch(0 0 270)", +"oklch(0% 0% 270deg / 1)", "oklch(0 0 270)", +"oklch(10 0 270)", "oklch(10 0 270)", +"oklch(10% 0% 270deg)", "oklch(0.1 0 270)", +"oklch(10 0 270 / 0)", "oklch(10 0 270 / 0)", +"oklch(10% 0% 270deg / 0)", "oklch(0.1 0 270 / 0)", +"oklch(10 0 270 / 0.2)", "oklch(10 0 270 / 0.2)", +"oklch(10% 0% 270deg / 0.2)", "oklch(0.1 0 270 / 0.2)", +"oklch(10 0 270 / 1)", "oklch(10 0 270)", +"oklch(10% 0% 270deg / 1)", "oklch(0.1 0 270)", +"oklch(110 0 270)", "oklch(110 0 270)", +"oklch(110% 0% 270deg)", "oklch(1.1 0 270)", +"oklch(110 0 270 / 0)", "oklch(110 0 270 / 0)", +"oklch(110% 0% 270deg / 0)", "oklch(1.1 0 270 / 0)", +"oklch(110 0 270 / 0.2)", "oklch(110 0 270 / 0.2)", +"oklch(110% 0% 270deg / 0.2)", "oklch(1.1 0 270 / 0.2)", +"oklch(110 0 270 / 1)", "oklch(110 0 270)", +"oklch(110% 0% 270deg / 1)", "oklch(1.1 0 270)", +"oklch(-10 0 270)", "oklch(-10 0 270)", +"oklch(-10% 0% 270deg)", "oklch(-0.1 0 270)", +"oklch(-10 0 270 / 0)", "oklch(-10 0 270 / 0)", +"oklch(-10% 0% 270deg / 0)", "oklch(-0.1 0 270 / 0)", +"oklch(-10 0 270 / 0.2)", "oklch(-10 0 270 / 0.2)", +"oklch(-10% 0% 270deg / 0.2)", "oklch(-0.1 0 270 / 0.2)", +"oklch(-10 0 270 / 1)", "oklch(-10 0 270)", +"oklch(-10% 0% 270deg / 1)", "oklch(-0.1 0 270)", +"oklch(0 10 270)", "oklch(0 10 270)", +"oklch(0% 10% 270deg)", "oklch(0 0.04 270)", +"oklch(0 10 270 / 0)", "oklch(0 10 270 / 0)", +"oklch(0% 10% 270deg / 0)", "oklch(0 0.04 270 / 0)", +"oklch(0 10 270 / 0.2)", "oklch(0 10 270 / 0.2)", +"oklch(0% 10% 270deg / 0.2)", "oklch(0 0.04 270 / 0.2)", +"oklch(0 10 270 / 1)", "oklch(0 10 270)", +"oklch(0% 10% 270deg / 1)", "oklch(0 0.04 270)", +"oklch(10 10 270)", "oklch(10 10 270)", +"oklch(10% 10% 270deg)", "oklch(0.1 0.04 270)", +"oklch(10 10 270 / 0)", "oklch(10 10 270 / 0)", +"oklch(10% 10% 270deg / 0)", "oklch(0.1 0.04 270 / 0)", +"oklch(10 10 270 / 0.2)", "oklch(10 10 270 / 0.2)", +"oklch(10% 10% 270deg / 0.2)", "oklch(0.1 0.04 270 / 0.2)", +"oklch(10 10 270 / 1)", "oklch(10 10 270)", +"oklch(10% 10% 270deg / 1)", "oklch(0.1 0.04 270)", +"oklch(110 10 270)", "oklch(110 10 270)", +"oklch(110% 10% 270deg)", "oklch(1.1 0.04 270)", +"oklch(110 10 270 / 0)", "oklch(110 10 270 / 0)", +"oklch(110% 10% 270deg / 0)", "oklch(1.1 0.04 270 / 0)", +"oklch(110 10 270 / 0.2)", "oklch(110 10 270 / 0.2)", +"oklch(110% 10% 270deg / 0.2)", "oklch(1.1 0.04 270 / 0.2)", +"oklch(110 10 270 / 1)", "oklch(110 10 270)", +"oklch(110% 10% 270deg / 1)", "oklch(1.1 0.04 270)", +"oklch(-10 10 270)", "oklch(-10 10 270)", +"oklch(-10% 10% 270deg)", "oklch(-0.1 0.04 270)", +"oklch(-10 10 270 / 0)", "oklch(-10 10 270 / 0)", +"oklch(-10% 10% 270deg / 0)", "oklch(-0.1 0.04 270 / 0)", +"oklch(-10 10 270 / 0.2)", "oklch(-10 10 270 / 0.2)", +"oklch(-10% 10% 270deg / 0.2)", "oklch(-0.1 0.04 270 / 0.2)", +"oklch(-10 10 270 / 1)", "oklch(-10 10 270)", +"oklch(-10% 10% 270deg / 1)", "oklch(-0.1 0.04 270)", +"oklch(0 110 270)", "oklch(0 110 270)", +"oklch(0% 110% 270deg)", "oklch(0 0.44 270)", +"oklch(0 110 270 / 0)", "oklch(0 110 270 / 0)", +"oklch(0% 110% 270deg / 0)", "oklch(0 0.44 270 / 0)", +"oklch(0 110 270 / 0.2)", "oklch(0 110 270 / 0.2)", +"oklch(0% 110% 270deg / 0.2)", "oklch(0 0.44 270 / 0.2)", +"oklch(0 110 270 / 1)", "oklch(0 110 270)", +"oklch(0% 110% 270deg / 1)", "oklch(0 0.44 270)", +"oklch(10 110 270)", "oklch(10 110 270)", +"oklch(10% 110% 270deg)", "oklch(0.1 0.44 270)", +"oklch(10 110 270 / 0)", "oklch(10 110 270 / 0)", +"oklch(10% 110% 270deg / 0)", "oklch(0.1 0.44 270 / 0)", +"oklch(10 110 270 / 0.2)", "oklch(10 110 270 / 0.2)", +"oklch(10% 110% 270deg / 0.2)", "oklch(0.1 0.44 270 / 0.2)", +"oklch(10 110 270 / 1)", "oklch(10 110 270)", +"oklch(10% 110% 270deg / 1)", "oklch(0.1 0.44 270)", +"oklch(110 110 270)", "oklch(110 110 270)", +"oklch(110% 110% 270deg)", "oklch(1.1 0.44 270)", +"oklch(110 110 270 / 0)", "oklch(110 110 270 / 0)", +"oklch(110% 110% 270deg / 0)", "oklch(1.1 0.44 270 / 0)", +"oklch(110 110 270 / 0.2)", "oklch(110 110 270 / 0.2)", +"oklch(110% 110% 270deg / 0.2)", "oklch(1.1 0.44 270 / 0.2)", +"oklch(110 110 270 / 1)", "oklch(110 110 270)", +"oklch(110% 110% 270deg / 1)", "oklch(1.1 0.44 270)", +"oklch(-10 110 270)", "oklch(-10 110 270)", +"oklch(-10% 110% 270deg)", "oklch(-0.1 0.44 270)", +"oklch(-10 110 270 / 0)", "oklch(-10 110 270 / 0)", +"oklch(-10% 110% 270deg / 0)", "oklch(-0.1 0.44 270 / 0)", +"oklch(-10 110 270 / 0.2)", "oklch(-10 110 270 / 0.2)", +"oklch(-10% 110% 270deg / 0.2)", "oklch(-0.1 0.44 270 / 0.2)", +"oklch(-10 110 270 / 1)", "oklch(-10 110 270)", +"oklch(-10% 110% 270deg / 1)", "oklch(-0.1 0.44 270)", +"oklch(0 -10 270)", "oklch(0 -10 270)", +"oklch(0% -10% 270deg)", "oklch(0 -0.04 270)", +"oklch(0 -10 270 / 0)", "oklch(0 -10 270 / 0)", +"oklch(0% -10% 270deg / 0)", "oklch(0 -0.04 270 / 0)", +"oklch(0 -10 270 / 0.2)", "oklch(0 -10 270 / 0.2)", +"oklch(0% -10% 270deg / 0.2)", "oklch(0 -0.04 270 / 0.2)", +"oklch(0 -10 270 / 1)", "oklch(0 -10 270)", +"oklch(0% -10% 270deg / 1)", "oklch(0 -0.04 270)", +"oklch(10 -10 270)", "oklch(10 -10 270)", +"oklch(10% -10% 270deg)", "oklch(0.1 -0.04 270)", +"oklch(10 -10 270 / 0)", "oklch(10 -10 270 / 0)", +"oklch(10% -10% 270deg / 0)", "oklch(0.1 -0.04 270 / 0)", +"oklch(10 -10 270 / 0.2)", "oklch(10 -10 270 / 0.2)", +"oklch(10% -10% 270deg / 0.2)", "oklch(0.1 -0.04 270 / 0.2)", +"oklch(10 -10 270 / 1)", "oklch(10 -10 270)", +"oklch(10% -10% 270deg / 1)", "oklch(0.1 -0.04 270)", +"oklch(110 -10 270)", "oklch(110 -10 270)", +"oklch(110% -10% 270deg)", "oklch(1.1 -0.04 270)", +"oklch(110 -10 270 / 0)", "oklch(110 -10 270 / 0)", +"oklch(110% -10% 270deg / 0)", "oklch(1.1 -0.04 270 / 0)", +"oklch(110 -10 270 / 0.2)", "oklch(110 -10 270 / 0.2)", +"oklch(110% -10% 270deg / 0.2)", "oklch(1.1 -0.04 270 / 0.2)", +"oklch(110 -10 270 / 1)", "oklch(110 -10 270)", +"oklch(110% -10% 270deg / 1)", "oklch(1.1 -0.04 270)", +"oklch(-10 -10 270)", "oklch(-10 -10 270)", +"oklch(-10% -10% 270deg)", "oklch(-0.1 -0.04 270)", +"oklch(-10 -10 270 / 0)", "oklch(-10 -10 270 / 0)", +"oklch(-10% -10% 270deg / 0)", "oklch(-0.1 -0.04 270 / 0)", +"oklch(-10 -10 270 / 0.2)", "oklch(-10 -10 270 / 0.2)", +"oklch(-10% -10% 270deg / 0.2)", "oklch(-0.1 -0.04 270 / 0.2)", +"oklch(-10 -10 270 / 1)", "oklch(-10 -10 270)", +"oklch(-10% -10% 270deg / 1)", "oklch(-0.1 -0.04 270)", +"oklch(0 0 300)", "oklch(0 0 300)", +"oklch(0% 0% 300deg)", "oklch(0 0 300)", +"oklch(0 0 300 / 0)", "oklch(0 0 300 / 0)", +"oklch(0% 0% 300deg / 0)", "oklch(0 0 300 / 0)", +"oklch(0 0 300 / 0.2)", "oklch(0 0 300 / 0.2)", +"oklch(0% 0% 300deg / 0.2)", "oklch(0 0 300 / 0.2)", +"oklch(0 0 300 / 1)", "oklch(0 0 300)", +"oklch(0% 0% 300deg / 1)", "oklch(0 0 300)", +"oklch(10 0 300)", "oklch(10 0 300)", +"oklch(10% 0% 300deg)", "oklch(0.1 0 300)", +"oklch(10 0 300 / 0)", "oklch(10 0 300 / 0)", +"oklch(10% 0% 300deg / 0)", "oklch(0.1 0 300 / 0)", +"oklch(10 0 300 / 0.2)", "oklch(10 0 300 / 0.2)", +"oklch(10% 0% 300deg / 0.2)", "oklch(0.1 0 300 / 0.2)", +"oklch(10 0 300 / 1)", "oklch(10 0 300)", +"oklch(10% 0% 300deg / 1)", "oklch(0.1 0 300)", +"oklch(110 0 300)", "oklch(110 0 300)", +"oklch(110% 0% 300deg)", "oklch(1.1 0 300)", +"oklch(110 0 300 / 0)", "oklch(110 0 300 / 0)", +"oklch(110% 0% 300deg / 0)", "oklch(1.1 0 300 / 0)", +"oklch(110 0 300 / 0.2)", "oklch(110 0 300 / 0.2)", +"oklch(110% 0% 300deg / 0.2)", "oklch(1.1 0 300 / 0.2)", +"oklch(110 0 300 / 1)", "oklch(110 0 300)", +"oklch(110% 0% 300deg / 1)", "oklch(1.1 0 300)", +"oklch(-10 0 300)", "oklch(-10 0 300)", +"oklch(-10% 0% 300deg)", "oklch(-0.1 0 300)", +"oklch(-10 0 300 / 0)", "oklch(-10 0 300 / 0)", +"oklch(-10% 0% 300deg / 0)", "oklch(-0.1 0 300 / 0)", +"oklch(-10 0 300 / 0.2)", "oklch(-10 0 300 / 0.2)", +"oklch(-10% 0% 300deg / 0.2)", "oklch(-0.1 0 300 / 0.2)", +"oklch(-10 0 300 / 1)", "oklch(-10 0 300)", +"oklch(-10% 0% 300deg / 1)", "oklch(-0.1 0 300)", +"oklch(0 10 300)", "oklch(0 10 300)", +"oklch(0% 10% 300deg)", "oklch(0 0.04 300)", +"oklch(0 10 300 / 0)", "oklch(0 10 300 / 0)", +"oklch(0% 10% 300deg / 0)", "oklch(0 0.04 300 / 0)", +"oklch(0 10 300 / 0.2)", "oklch(0 10 300 / 0.2)", +"oklch(0% 10% 300deg / 0.2)", "oklch(0 0.04 300 / 0.2)", +"oklch(0 10 300 / 1)", "oklch(0 10 300)", +"oklch(0% 10% 300deg / 1)", "oklch(0 0.04 300)", +"oklch(10 10 300)", "oklch(10 10 300)", +"oklch(10% 10% 300deg)", "oklch(0.1 0.04 300)", +"oklch(10 10 300 / 0)", "oklch(10 10 300 / 0)", +"oklch(10% 10% 300deg / 0)", "oklch(0.1 0.04 300 / 0)", +"oklch(10 10 300 / 0.2)", "oklch(10 10 300 / 0.2)", +"oklch(10% 10% 300deg / 0.2)", "oklch(0.1 0.04 300 / 0.2)", +"oklch(10 10 300 / 1)", "oklch(10 10 300)", +"oklch(10% 10% 300deg / 1)", "oklch(0.1 0.04 300)", +"oklch(110 10 300)", "oklch(110 10 300)", +"oklch(110% 10% 300deg)", "oklch(1.1 0.04 300)", +"oklch(110 10 300 / 0)", "oklch(110 10 300 / 0)", +"oklch(110% 10% 300deg / 0)", "oklch(1.1 0.04 300 / 0)", +"oklch(110 10 300 / 0.2)", "oklch(110 10 300 / 0.2)", +"oklch(110% 10% 300deg / 0.2)", "oklch(1.1 0.04 300 / 0.2)", +"oklch(110 10 300 / 1)", "oklch(110 10 300)", +"oklch(110% 10% 300deg / 1)", "oklch(1.1 0.04 300)", +"oklch(-10 10 300)", "oklch(-10 10 300)", +"oklch(-10% 10% 300deg)", "oklch(-0.1 0.04 300)", +"oklch(-10 10 300 / 0)", "oklch(-10 10 300 / 0)", +"oklch(-10% 10% 300deg / 0)", "oklch(-0.1 0.04 300 / 0)", +"oklch(-10 10 300 / 0.2)", "oklch(-10 10 300 / 0.2)", +"oklch(-10% 10% 300deg / 0.2)", "oklch(-0.1 0.04 300 / 0.2)", +"oklch(-10 10 300 / 1)", "oklch(-10 10 300)", +"oklch(-10% 10% 300deg / 1)", "oklch(-0.1 0.04 300)", +"oklch(0 110 300)", "oklch(0 110 300)", +"oklch(0% 110% 300deg)", "oklch(0 0.44 300)", +"oklch(0 110 300 / 0)", "oklch(0 110 300 / 0)", +"oklch(0% 110% 300deg / 0)", "oklch(0 0.44 300 / 0)", +"oklch(0 110 300 / 0.2)", "oklch(0 110 300 / 0.2)", +"oklch(0% 110% 300deg / 0.2)", "oklch(0 0.44 300 / 0.2)", +"oklch(0 110 300 / 1)", "oklch(0 110 300)", +"oklch(0% 110% 300deg / 1)", "oklch(0 0.44 300)", +"oklch(10 110 300)", "oklch(10 110 300)", +"oklch(10% 110% 300deg)", "oklch(0.1 0.44 300)", +"oklch(10 110 300 / 0)", "oklch(10 110 300 / 0)", +"oklch(10% 110% 300deg / 0)", "oklch(0.1 0.44 300 / 0)", +"oklch(10 110 300 / 0.2)", "oklch(10 110 300 / 0.2)", +"oklch(10% 110% 300deg / 0.2)", "oklch(0.1 0.44 300 / 0.2)", +"oklch(10 110 300 / 1)", "oklch(10 110 300)", +"oklch(10% 110% 300deg / 1)", "oklch(0.1 0.44 300)", +"oklch(110 110 300)", "oklch(110 110 300)", +"oklch(110% 110% 300deg)", "oklch(1.1 0.44 300)", +"oklch(110 110 300 / 0)", "oklch(110 110 300 / 0)", +"oklch(110% 110% 300deg / 0)", "oklch(1.1 0.44 300 / 0)", +"oklch(110 110 300 / 0.2)", "oklch(110 110 300 / 0.2)", +"oklch(110% 110% 300deg / 0.2)", "oklch(1.1 0.44 300 / 0.2)", +"oklch(110 110 300 / 1)", "oklch(110 110 300)", +"oklch(110% 110% 300deg / 1)", "oklch(1.1 0.44 300)", +"oklch(-10 110 300)", "oklch(-10 110 300)", +"oklch(-10% 110% 300deg)", "oklch(-0.1 0.44 300)", +"oklch(-10 110 300 / 0)", "oklch(-10 110 300 / 0)", +"oklch(-10% 110% 300deg / 0)", "oklch(-0.1 0.44 300 / 0)", +"oklch(-10 110 300 / 0.2)", "oklch(-10 110 300 / 0.2)", +"oklch(-10% 110% 300deg / 0.2)", "oklch(-0.1 0.44 300 / 0.2)", +"oklch(-10 110 300 / 1)", "oklch(-10 110 300)", +"oklch(-10% 110% 300deg / 1)", "oklch(-0.1 0.44 300)", +"oklch(0 -10 300)", "oklch(0 -10 300)", +"oklch(0% -10% 300deg)", "oklch(0 -0.04 300)", +"oklch(0 -10 300 / 0)", "oklch(0 -10 300 / 0)", +"oklch(0% -10% 300deg / 0)", "oklch(0 -0.04 300 / 0)", +"oklch(0 -10 300 / 0.2)", "oklch(0 -10 300 / 0.2)", +"oklch(0% -10% 300deg / 0.2)", "oklch(0 -0.04 300 / 0.2)", +"oklch(0 -10 300 / 1)", "oklch(0 -10 300)", +"oklch(0% -10% 300deg / 1)", "oklch(0 -0.04 300)", +"oklch(10 -10 300)", "oklch(10 -10 300)", +"oklch(10% -10% 300deg)", "oklch(0.1 -0.04 300)", +"oklch(10 -10 300 / 0)", "oklch(10 -10 300 / 0)", +"oklch(10% -10% 300deg / 0)", "oklch(0.1 -0.04 300 / 0)", +"oklch(10 -10 300 / 0.2)", "oklch(10 -10 300 / 0.2)", +"oklch(10% -10% 300deg / 0.2)", "oklch(0.1 -0.04 300 / 0.2)", +"oklch(10 -10 300 / 1)", "oklch(10 -10 300)", +"oklch(10% -10% 300deg / 1)", "oklch(0.1 -0.04 300)", +"oklch(110 -10 300)", "oklch(110 -10 300)", +"oklch(110% -10% 300deg)", "oklch(1.1 -0.04 300)", +"oklch(110 -10 300 / 0)", "oklch(110 -10 300 / 0)", +"oklch(110% -10% 300deg / 0)", "oklch(1.1 -0.04 300 / 0)", +"oklch(110 -10 300 / 0.2)", "oklch(110 -10 300 / 0.2)", +"oklch(110% -10% 300deg / 0.2)", "oklch(1.1 -0.04 300 / 0.2)", +"oklch(110 -10 300 / 1)", "oklch(110 -10 300)", +"oklch(110% -10% 300deg / 1)", "oklch(1.1 -0.04 300)", +"oklch(-10 -10 300)", "oklch(-10 -10 300)", +"oklch(-10% -10% 300deg)", "oklch(-0.1 -0.04 300)", +"oklch(-10 -10 300 / 0)", "oklch(-10 -10 300 / 0)", +"oklch(-10% -10% 300deg / 0)", "oklch(-0.1 -0.04 300 / 0)", +"oklch(-10 -10 300 / 0.2)", "oklch(-10 -10 300 / 0.2)", +"oklch(-10% -10% 300deg / 0.2)", "oklch(-0.1 -0.04 300 / 0.2)", +"oklch(-10 -10 300 / 1)", "oklch(-10 -10 300)", +"oklch(-10% -10% 300deg / 1)", "oklch(-0.1 -0.04 300)", +"oklch(0 0 330)", "oklch(0 0 330)", +"oklch(0% 0% 330deg)", "oklch(0 0 330)", +"oklch(0 0 330 / 0)", "oklch(0 0 330 / 0)", +"oklch(0% 0% 330deg / 0)", "oklch(0 0 330 / 0)", +"oklch(0 0 330 / 0.2)", "oklch(0 0 330 / 0.2)", +"oklch(0% 0% 330deg / 0.2)", "oklch(0 0 330 / 0.2)", +"oklch(0 0 330 / 1)", "oklch(0 0 330)", +"oklch(0% 0% 330deg / 1)", "oklch(0 0 330)", +"oklch(10 0 330)", "oklch(10 0 330)", +"oklch(10% 0% 330deg)", "oklch(0.1 0 330)", +"oklch(10 0 330 / 0)", "oklch(10 0 330 / 0)", +"oklch(10% 0% 330deg / 0)", "oklch(0.1 0 330 / 0)", +"oklch(10 0 330 / 0.2)", "oklch(10 0 330 / 0.2)", +"oklch(10% 0% 330deg / 0.2)", "oklch(0.1 0 330 / 0.2)", +"oklch(10 0 330 / 1)", "oklch(10 0 330)", +"oklch(10% 0% 330deg / 1)", "oklch(0.1 0 330)", +"oklch(110 0 330)", "oklch(110 0 330)", +"oklch(110% 0% 330deg)", "oklch(1.1 0 330)", +"oklch(110 0 330 / 0)", "oklch(110 0 330 / 0)", +"oklch(110% 0% 330deg / 0)", "oklch(1.1 0 330 / 0)", +"oklch(110 0 330 / 0.2)", "oklch(110 0 330 / 0.2)", +"oklch(110% 0% 330deg / 0.2)", "oklch(1.1 0 330 / 0.2)", +"oklch(110 0 330 / 1)", "oklch(110 0 330)", +"oklch(110% 0% 330deg / 1)", "oklch(1.1 0 330)", +"oklch(-10 0 330)", "oklch(-10 0 330)", +"oklch(-10% 0% 330deg)", "oklch(-0.1 0 330)", +"oklch(-10 0 330 / 0)", "oklch(-10 0 330 / 0)", +"oklch(-10% 0% 330deg / 0)", "oklch(-0.1 0 330 / 0)", +"oklch(-10 0 330 / 0.2)", "oklch(-10 0 330 / 0.2)", +"oklch(-10% 0% 330deg / 0.2)", "oklch(-0.1 0 330 / 0.2)", +"oklch(-10 0 330 / 1)", "oklch(-10 0 330)", +"oklch(-10% 0% 330deg / 1)", "oklch(-0.1 0 330)", +"oklch(0 10 330)", "oklch(0 10 330)", +"oklch(0% 10% 330deg)", "oklch(0 0.04 330)", +"oklch(0 10 330 / 0)", "oklch(0 10 330 / 0)", +"oklch(0% 10% 330deg / 0)", "oklch(0 0.04 330 / 0)", +"oklch(0 10 330 / 0.2)", "oklch(0 10 330 / 0.2)", +"oklch(0% 10% 330deg / 0.2)", "oklch(0 0.04 330 / 0.2)", +"oklch(0 10 330 / 1)", "oklch(0 10 330)", +"oklch(0% 10% 330deg / 1)", "oklch(0 0.04 330)", +"oklch(10 10 330)", "oklch(10 10 330)", +"oklch(10% 10% 330deg)", "oklch(0.1 0.04 330)", +"oklch(10 10 330 / 0)", "oklch(10 10 330 / 0)", +"oklch(10% 10% 330deg / 0)", "oklch(0.1 0.04 330 / 0)", +"oklch(10 10 330 / 0.2)", "oklch(10 10 330 / 0.2)", +"oklch(10% 10% 330deg / 0.2)", "oklch(0.1 0.04 330 / 0.2)", +"oklch(10 10 330 / 1)", "oklch(10 10 330)", +"oklch(10% 10% 330deg / 1)", "oklch(0.1 0.04 330)", +"oklch(110 10 330)", "oklch(110 10 330)", +"oklch(110% 10% 330deg)", "oklch(1.1 0.04 330)", +"oklch(110 10 330 / 0)", "oklch(110 10 330 / 0)", +"oklch(110% 10% 330deg / 0)", "oklch(1.1 0.04 330 / 0)", +"oklch(110 10 330 / 0.2)", "oklch(110 10 330 / 0.2)", +"oklch(110% 10% 330deg / 0.2)", "oklch(1.1 0.04 330 / 0.2)", +"oklch(110 10 330 / 1)", "oklch(110 10 330)", +"oklch(110% 10% 330deg / 1)", "oklch(1.1 0.04 330)", +"oklch(-10 10 330)", "oklch(-10 10 330)", +"oklch(-10% 10% 330deg)", "oklch(-0.1 0.04 330)", +"oklch(-10 10 330 / 0)", "oklch(-10 10 330 / 0)", +"oklch(-10% 10% 330deg / 0)", "oklch(-0.1 0.04 330 / 0)", +"oklch(-10 10 330 / 0.2)", "oklch(-10 10 330 / 0.2)", +"oklch(-10% 10% 330deg / 0.2)", "oklch(-0.1 0.04 330 / 0.2)", +"oklch(-10 10 330 / 1)", "oklch(-10 10 330)", +"oklch(-10% 10% 330deg / 1)", "oklch(-0.1 0.04 330)", +"oklch(0 110 330)", "oklch(0 110 330)", +"oklch(0% 110% 330deg)", "oklch(0 0.44 330)", +"oklch(0 110 330 / 0)", "oklch(0 110 330 / 0)", +"oklch(0% 110% 330deg / 0)", "oklch(0 0.44 330 / 0)", +"oklch(0 110 330 / 0.2)", "oklch(0 110 330 / 0.2)", +"oklch(0% 110% 330deg / 0.2)", "oklch(0 0.44 330 / 0.2)", +"oklch(0 110 330 / 1)", "oklch(0 110 330)", +"oklch(0% 110% 330deg / 1)", "oklch(0 0.44 330)", +"oklch(10 110 330)", "oklch(10 110 330)", +"oklch(10% 110% 330deg)", "oklch(0.1 0.44 330)", +"oklch(10 110 330 / 0)", "oklch(10 110 330 / 0)", +"oklch(10% 110% 330deg / 0)", "oklch(0.1 0.44 330 / 0)", +"oklch(10 110 330 / 0.2)", "oklch(10 110 330 / 0.2)", +"oklch(10% 110% 330deg / 0.2)", "oklch(0.1 0.44 330 / 0.2)", +"oklch(10 110 330 / 1)", "oklch(10 110 330)", +"oklch(10% 110% 330deg / 1)", "oklch(0.1 0.44 330)", +"oklch(110 110 330)", "oklch(110 110 330)", +"oklch(110% 110% 330deg)", "oklch(1.1 0.44 330)", +"oklch(110 110 330 / 0)", "oklch(110 110 330 / 0)", +"oklch(110% 110% 330deg / 0)", "oklch(1.1 0.44 330 / 0)", +"oklch(110 110 330 / 0.2)", "oklch(110 110 330 / 0.2)", +"oklch(110% 110% 330deg / 0.2)", "oklch(1.1 0.44 330 / 0.2)", +"oklch(110 110 330 / 1)", "oklch(110 110 330)", +"oklch(110% 110% 330deg / 1)", "oklch(1.1 0.44 330)", +"oklch(-10 110 330)", "oklch(-10 110 330)", +"oklch(-10% 110% 330deg)", "oklch(-0.1 0.44 330)", +"oklch(-10 110 330 / 0)", "oklch(-10 110 330 / 0)", +"oklch(-10% 110% 330deg / 0)", "oklch(-0.1 0.44 330 / 0)", +"oklch(-10 110 330 / 0.2)", "oklch(-10 110 330 / 0.2)", +"oklch(-10% 110% 330deg / 0.2)", "oklch(-0.1 0.44 330 / 0.2)", +"oklch(-10 110 330 / 1)", "oklch(-10 110 330)", +"oklch(-10% 110% 330deg / 1)", "oklch(-0.1 0.44 330)", +"oklch(0 -10 330)", "oklch(0 -10 330)", +"oklch(0% -10% 330deg)", "oklch(0 -0.04 330)", +"oklch(0 -10 330 / 0)", "oklch(0 -10 330 / 0)", +"oklch(0% -10% 330deg / 0)", "oklch(0 -0.04 330 / 0)", +"oklch(0 -10 330 / 0.2)", "oklch(0 -10 330 / 0.2)", +"oklch(0% -10% 330deg / 0.2)", "oklch(0 -0.04 330 / 0.2)", +"oklch(0 -10 330 / 1)", "oklch(0 -10 330)", +"oklch(0% -10% 330deg / 1)", "oklch(0 -0.04 330)", +"oklch(10 -10 330)", "oklch(10 -10 330)", +"oklch(10% -10% 330deg)", "oklch(0.1 -0.04 330)", +"oklch(10 -10 330 / 0)", "oklch(10 -10 330 / 0)", +"oklch(10% -10% 330deg / 0)", "oklch(0.1 -0.04 330 / 0)", +"oklch(10 -10 330 / 0.2)", "oklch(10 -10 330 / 0.2)", +"oklch(10% -10% 330deg / 0.2)", "oklch(0.1 -0.04 330 / 0.2)", +"oklch(10 -10 330 / 1)", "oklch(10 -10 330)", +"oklch(10% -10% 330deg / 1)", "oklch(0.1 -0.04 330)", +"oklch(110 -10 330)", "oklch(110 -10 330)", +"oklch(110% -10% 330deg)", "oklch(1.1 -0.04 330)", +"oklch(110 -10 330 / 0)", "oklch(110 -10 330 / 0)", +"oklch(110% -10% 330deg / 0)", "oklch(1.1 -0.04 330 / 0)", +"oklch(110 -10 330 / 0.2)", "oklch(110 -10 330 / 0.2)", +"oklch(110% -10% 330deg / 0.2)", "oklch(1.1 -0.04 330 / 0.2)", +"oklch(110 -10 330 / 1)", "oklch(110 -10 330)", +"oklch(110% -10% 330deg / 1)", "oklch(1.1 -0.04 330)", +"oklch(-10 -10 330)", "oklch(-10 -10 330)", +"oklch(-10% -10% 330deg)", "oklch(-0.1 -0.04 330)", +"oklch(-10 -10 330 / 0)", "oklch(-10 -10 330 / 0)", +"oklch(-10% -10% 330deg / 0)", "oklch(-0.1 -0.04 330 / 0)", +"oklch(-10 -10 330 / 0.2)", "oklch(-10 -10 330 / 0.2)", +"oklch(-10% -10% 330deg / 0.2)", "oklch(-0.1 -0.04 330 / 0.2)", +"oklch(-10 -10 330 / 1)", "oklch(-10 -10 330)", +"oklch(-10% -10% 330deg / 1)", "oklch(-0.1 -0.04 330)", +"oklch(0 0 360)", "oklch(0 0 0)", +"oklch(0% 0% 360deg)", "oklch(0 0 0)", +"oklch(0 0 360 / 0)", "oklch(0 0 0 / 0)", +"oklch(0% 0% 360deg / 0)", "oklch(0 0 0 / 0)", +"oklch(0 0 360 / 0.2)", "oklch(0 0 0 / 0.2)", +"oklch(0% 0% 360deg / 0.2)", "oklch(0 0 0 / 0.2)", +"oklch(0 0 360 / 1)", "oklch(0 0 0)", +"oklch(0% 0% 360deg / 1)", "oklch(0 0 0)", +"oklch(10 0 360)", "oklch(10 0 0)", +"oklch(10% 0% 360deg)", "oklch(0.1 0 0)", +"oklch(10 0 360 / 0)", "oklch(10 0 0 / 0)", +"oklch(10% 0% 360deg / 0)", "oklch(0.1 0 0 / 0)", +"oklch(10 0 360 / 0.2)", "oklch(10 0 0 / 0.2)", +"oklch(10% 0% 360deg / 0.2)", "oklch(0.1 0 0 / 0.2)", +"oklch(10 0 360 / 1)", "oklch(10 0 0)", +"oklch(10% 0% 360deg / 1)", "oklch(0.1 0 0)", +"oklch(110 0 360)", "oklch(110 0 0)", +"oklch(110% 0% 360deg)", "oklch(1.1 0 0)", +"oklch(110 0 360 / 0)", "oklch(110 0 0 / 0)", +"oklch(110% 0% 360deg / 0)", "oklch(1.1 0 0 / 0)", +"oklch(110 0 360 / 0.2)", "oklch(110 0 0 / 0.2)", +"oklch(110% 0% 360deg / 0.2)", "oklch(1.1 0 0 / 0.2)", +"oklch(110 0 360 / 1)", "oklch(110 0 0)", +"oklch(110% 0% 360deg / 1)", "oklch(1.1 0 0)", +"oklch(-10 0 360)", "oklch(-10 0 0)", +"oklch(-10% 0% 360deg)", "oklch(-0.1 0 0)", +"oklch(-10 0 360 / 0)", "oklch(-10 0 0 / 0)", +"oklch(-10% 0% 360deg / 0)", "oklch(-0.1 0 0 / 0)", +"oklch(-10 0 360 / 0.2)", "oklch(-10 0 0 / 0.2)", +"oklch(-10% 0% 360deg / 0.2)", "oklch(-0.1 0 0 / 0.2)", +"oklch(-10 0 360 / 1)", "oklch(-10 0 0)", +"oklch(-10% 0% 360deg / 1)", "oklch(-0.1 0 0)", +"oklch(0 10 360)", "oklch(0 10 0)", +"oklch(0% 10% 360deg)", "oklch(0 0.04 0)", +"oklch(0 10 360 / 0)", "oklch(0 10 0 / 0)", +"oklch(0% 10% 360deg / 0)", "oklch(0 0.04 0 / 0)", +"oklch(0 10 360 / 0.2)", "oklch(0 10 0 / 0.2)", +"oklch(0% 10% 360deg / 0.2)", "oklch(0 0.04 0 / 0.2)", +"oklch(0 10 360 / 1)", "oklch(0 10 0)", +"oklch(0% 10% 360deg / 1)", "oklch(0 0.04 0)", +"oklch(10 10 360)", "oklch(10 10 0)", +"oklch(10% 10% 360deg)", "oklch(0.1 0.04 0)", +"oklch(10 10 360 / 0)", "oklch(10 10 0 / 0)", +"oklch(10% 10% 360deg / 0)", "oklch(0.1 0.04 0 / 0)", +"oklch(10 10 360 / 0.2)", "oklch(10 10 0 / 0.2)", +"oklch(10% 10% 360deg / 0.2)", "oklch(0.1 0.04 0 / 0.2)", +"oklch(10 10 360 / 1)", "oklch(10 10 0)", +"oklch(10% 10% 360deg / 1)", "oklch(0.1 0.04 0)", +"oklch(110 10 360)", "oklch(110 10 0)", +"oklch(110% 10% 360deg)", "oklch(1.1 0.04 0)", +"oklch(110 10 360 / 0)", "oklch(110 10 0 / 0)", +"oklch(110% 10% 360deg / 0)", "oklch(1.1 0.04 0 / 0)", +"oklch(110 10 360 / 0.2)", "oklch(110 10 0 / 0.2)", +"oklch(110% 10% 360deg / 0.2)", "oklch(1.1 0.04 0 / 0.2)", +"oklch(110 10 360 / 1)", "oklch(110 10 0)", +"oklch(110% 10% 360deg / 1)", "oklch(1.1 0.04 0)", +"oklch(-10 10 360)", "oklch(-10 10 0)", +"oklch(-10% 10% 360deg)", "oklch(-0.1 0.04 0)", +"oklch(-10 10 360 / 0)", "oklch(-10 10 0 / 0)", +"oklch(-10% 10% 360deg / 0)", "oklch(-0.1 0.04 0 / 0)", +"oklch(-10 10 360 / 0.2)", "oklch(-10 10 0 / 0.2)", +"oklch(-10% 10% 360deg / 0.2)", "oklch(-0.1 0.04 0 / 0.2)", +"oklch(-10 10 360 / 1)", "oklch(-10 10 0)", +"oklch(-10% 10% 360deg / 1)", "oklch(-0.1 0.04 0)", +"oklch(0 110 360)", "oklch(0 110 0)", +"oklch(0% 110% 360deg)", "oklch(0 0.44 0)", +"oklch(0 110 360 / 0)", "oklch(0 110 0 / 0)", +"oklch(0% 110% 360deg / 0)", "oklch(0 0.44 0 / 0)", +"oklch(0 110 360 / 0.2)", "oklch(0 110 0 / 0.2)", +"oklch(0% 110% 360deg / 0.2)", "oklch(0 0.44 0 / 0.2)", +"oklch(0 110 360 / 1)", "oklch(0 110 0)", +"oklch(0% 110% 360deg / 1)", "oklch(0 0.44 0)", +"oklch(10 110 360)", "oklch(10 110 0)", +"oklch(10% 110% 360deg)", "oklch(0.1 0.44 0)", +"oklch(10 110 360 / 0)", "oklch(10 110 0 / 0)", +"oklch(10% 110% 360deg / 0)", "oklch(0.1 0.44 0 / 0)", +"oklch(10 110 360 / 0.2)", "oklch(10 110 0 / 0.2)", +"oklch(10% 110% 360deg / 0.2)", "oklch(0.1 0.44 0 / 0.2)", +"oklch(10 110 360 / 1)", "oklch(10 110 0)", +"oklch(10% 110% 360deg / 1)", "oklch(0.1 0.44 0)", +"oklch(110 110 360)", "oklch(110 110 0)", +"oklch(110% 110% 360deg)", "oklch(1.1 0.44 0)", +"oklch(110 110 360 / 0)", "oklch(110 110 0 / 0)", +"oklch(110% 110% 360deg / 0)", "oklch(1.1 0.44 0 / 0)", +"oklch(110 110 360 / 0.2)", "oklch(110 110 0 / 0.2)", +"oklch(110% 110% 360deg / 0.2)", "oklch(1.1 0.44 0 / 0.2)", +"oklch(110 110 360 / 1)", "oklch(110 110 0)", +"oklch(110% 110% 360deg / 1)", "oklch(1.1 0.44 0)", +"oklch(-10 110 360)", "oklch(-10 110 0)", +"oklch(-10% 110% 360deg)", "oklch(-0.1 0.44 0)", +"oklch(-10 110 360 / 0)", "oklch(-10 110 0 / 0)", +"oklch(-10% 110% 360deg / 0)", "oklch(-0.1 0.44 0 / 0)", +"oklch(-10 110 360 / 0.2)", "oklch(-10 110 0 / 0.2)", +"oklch(-10% 110% 360deg / 0.2)", "oklch(-0.1 0.44 0 / 0.2)", +"oklch(-10 110 360 / 1)", "oklch(-10 110 0)", +"oklch(-10% 110% 360deg / 1)", "oklch(-0.1 0.44 0)", +"oklch(0 -10 360)", "oklch(0 -10 0)", +"oklch(0% -10% 360deg)", "oklch(0 -0.04 0)", +"oklch(0 -10 360 / 0)", "oklch(0 -10 0 / 0)", +"oklch(0% -10% 360deg / 0)", "oklch(0 -0.04 0 / 0)", +"oklch(0 -10 360 / 0.2)", "oklch(0 -10 0 / 0.2)", +"oklch(0% -10% 360deg / 0.2)", "oklch(0 -0.04 0 / 0.2)", +"oklch(0 -10 360 / 1)", "oklch(0 -10 0)", +"oklch(0% -10% 360deg / 1)", "oklch(0 -0.04 0)", +"oklch(10 -10 360)", "oklch(10 -10 0)", +"oklch(10% -10% 360deg)", "oklch(0.1 -0.04 0)", +"oklch(10 -10 360 / 0)", "oklch(10 -10 0 / 0)", +"oklch(10% -10% 360deg / 0)", "oklch(0.1 -0.04 0 / 0)", +"oklch(10 -10 360 / 0.2)", "oklch(10 -10 0 / 0.2)", +"oklch(10% -10% 360deg / 0.2)", "oklch(0.1 -0.04 0 / 0.2)", +"oklch(10 -10 360 / 1)", "oklch(10 -10 0)", +"oklch(10% -10% 360deg / 1)", "oklch(0.1 -0.04 0)", +"oklch(110 -10 360)", "oklch(110 -10 0)", +"oklch(110% -10% 360deg)", "oklch(1.1 -0.04 0)", +"oklch(110 -10 360 / 0)", "oklch(110 -10 0 / 0)", +"oklch(110% -10% 360deg / 0)", "oklch(1.1 -0.04 0 / 0)", +"oklch(110 -10 360 / 0.2)", "oklch(110 -10 0 / 0.2)", +"oklch(110% -10% 360deg / 0.2)", "oklch(1.1 -0.04 0 / 0.2)", +"oklch(110 -10 360 / 1)", "oklch(110 -10 0)", +"oklch(110% -10% 360deg / 1)", "oklch(1.1 -0.04 0)", +"oklch(-10 -10 360)", "oklch(-10 -10 0)", +"oklch(-10% -10% 360deg)", "oklch(-0.1 -0.04 0)", +"oklch(-10 -10 360 / 0)", "oklch(-10 -10 0 / 0)", +"oklch(-10% -10% 360deg / 0)", "oklch(-0.1 -0.04 0 / 0)", +"oklch(-10 -10 360 / 0.2)", "oklch(-10 -10 0 / 0.2)", +"oklch(-10% -10% 360deg / 0.2)", "oklch(-0.1 -0.04 0 / 0.2)", +"oklch(-10 -10 360 / 1)", "oklch(-10 -10 0)", +"oklch(-10% -10% 360deg / 1)", "oklch(-0.1 -0.04 0)", +"oklch(0 0 380)", "oklch(0 0 20)", +"oklch(0% 0% 380deg)", "oklch(0 0 20)", +"oklch(0 0 380 / 0)", "oklch(0 0 20 / 0)", +"oklch(0% 0% 380deg / 0)", "oklch(0 0 20 / 0)", +"oklch(0 0 380 / 0.2)", "oklch(0 0 20 / 0.2)", +"oklch(0% 0% 380deg / 0.2)", "oklch(0 0 20 / 0.2)", +"oklch(0 0 380 / 1)", "oklch(0 0 20)", +"oklch(0% 0% 380deg / 1)", "oklch(0 0 20)", +"oklch(10 0 380)", "oklch(10 0 20)", +"oklch(10% 0% 380deg)", "oklch(0.1 0 20)", +"oklch(10 0 380 / 0)", "oklch(10 0 20 / 0)", +"oklch(10% 0% 380deg / 0)", "oklch(0.1 0 20 / 0)", +"oklch(10 0 380 / 0.2)", "oklch(10 0 20 / 0.2)", +"oklch(10% 0% 380deg / 0.2)", "oklch(0.1 0 20 / 0.2)", +"oklch(10 0 380 / 1)", "oklch(10 0 20)", +"oklch(10% 0% 380deg / 1)", "oklch(0.1 0 20)", +"oklch(110 0 380)", "oklch(110 0 20)", +"oklch(110% 0% 380deg)", "oklch(1.1 0 20)", +"oklch(110 0 380 / 0)", "oklch(110 0 20 / 0)", +"oklch(110% 0% 380deg / 0)", "oklch(1.1 0 20 / 0)", +"oklch(110 0 380 / 0.2)", "oklch(110 0 20 / 0.2)", +"oklch(110% 0% 380deg / 0.2)", "oklch(1.1 0 20 / 0.2)", +"oklch(110 0 380 / 1)", "oklch(110 0 20)", +"oklch(110% 0% 380deg / 1)", "oklch(1.1 0 20)", +"oklch(-10 0 380)", "oklch(-10 0 20)", +"oklch(-10% 0% 380deg)", "oklch(-0.1 0 20)", +"oklch(-10 0 380 / 0)", "oklch(-10 0 20 / 0)", +"oklch(-10% 0% 380deg / 0)", "oklch(-0.1 0 20 / 0)", +"oklch(-10 0 380 / 0.2)", "oklch(-10 0 20 / 0.2)", +"oklch(-10% 0% 380deg / 0.2)", "oklch(-0.1 0 20 / 0.2)", +"oklch(-10 0 380 / 1)", "oklch(-10 0 20)", +"oklch(-10% 0% 380deg / 1)", "oklch(-0.1 0 20)", +"oklch(0 10 380)", "oklch(0 10 20)", +"oklch(0% 10% 380deg)", "oklch(0 0.04 20)", +"oklch(0 10 380 / 0)", "oklch(0 10 20 / 0)", +"oklch(0% 10% 380deg / 0)", "oklch(0 0.04 20 / 0)", +"oklch(0 10 380 / 0.2)", "oklch(0 10 20 / 0.2)", +"oklch(0% 10% 380deg / 0.2)", "oklch(0 0.04 20 / 0.2)", +"oklch(0 10 380 / 1)", "oklch(0 10 20)", +"oklch(0% 10% 380deg / 1)", "oklch(0 0.04 20)", +"oklch(10 10 380)", "oklch(10 10 20)", +"oklch(10% 10% 380deg)", "oklch(0.1 0.04 20)", +"oklch(10 10 380 / 0)", "oklch(10 10 20 / 0)", +"oklch(10% 10% 380deg / 0)", "oklch(0.1 0.04 20 / 0)", +"oklch(10 10 380 / 0.2)", "oklch(10 10 20 / 0.2)", +"oklch(10% 10% 380deg / 0.2)", "oklch(0.1 0.04 20 / 0.2)", +"oklch(10 10 380 / 1)", "oklch(10 10 20)", +"oklch(10% 10% 380deg / 1)", "oklch(0.1 0.04 20)", +"oklch(110 10 380)", "oklch(110 10 20)", +"oklch(110% 10% 380deg)", "oklch(1.1 0.04 20)", +"oklch(110 10 380 / 0)", "oklch(110 10 20 / 0)", +"oklch(110% 10% 380deg / 0)", "oklch(1.1 0.04 20 / 0)", +"oklch(110 10 380 / 0.2)", "oklch(110 10 20 / 0.2)", +"oklch(110% 10% 380deg / 0.2)", "oklch(1.1 0.04 20 / 0.2)", +"oklch(110 10 380 / 1)", "oklch(110 10 20)", +"oklch(110% 10% 380deg / 1)", "oklch(1.1 0.04 20)", +"oklch(-10 10 380)", "oklch(-10 10 20)", +"oklch(-10% 10% 380deg)", "oklch(-0.1 0.04 20)", +"oklch(-10 10 380 / 0)", "oklch(-10 10 20 / 0)", +"oklch(-10% 10% 380deg / 0)", "oklch(-0.1 0.04 20 / 0)", +"oklch(-10 10 380 / 0.2)", "oklch(-10 10 20 / 0.2)", +"oklch(-10% 10% 380deg / 0.2)", "oklch(-0.1 0.04 20 / 0.2)", +"oklch(-10 10 380 / 1)", "oklch(-10 10 20)", +"oklch(-10% 10% 380deg / 1)", "oklch(-0.1 0.04 20)", +"oklch(0 110 380)", "oklch(0 110 20)", +"oklch(0% 110% 380deg)", "oklch(0 0.44 20)", +"oklch(0 110 380 / 0)", "oklch(0 110 20 / 0)", +"oklch(0% 110% 380deg / 0)", "oklch(0 0.44 20 / 0)", +"oklch(0 110 380 / 0.2)", "oklch(0 110 20 / 0.2)", +"oklch(0% 110% 380deg / 0.2)", "oklch(0 0.44 20 / 0.2)", +"oklch(0 110 380 / 1)", "oklch(0 110 20)", +"oklch(0% 110% 380deg / 1)", "oklch(0 0.44 20)", +"oklch(10 110 380)", "oklch(10 110 20)", +"oklch(10% 110% 380deg)", "oklch(0.1 0.44 20)", +"oklch(10 110 380 / 0)", "oklch(10 110 20 / 0)", +"oklch(10% 110% 380deg / 0)", "oklch(0.1 0.44 20 / 0)", +"oklch(10 110 380 / 0.2)", "oklch(10 110 20 / 0.2)", +"oklch(10% 110% 380deg / 0.2)", "oklch(0.1 0.44 20 / 0.2)", +"oklch(10 110 380 / 1)", "oklch(10 110 20)", +"oklch(10% 110% 380deg / 1)", "oklch(0.1 0.44 20)", +"oklch(110 110 380)", "oklch(110 110 20)", +"oklch(110% 110% 380deg)", "oklch(1.1 0.44 20)", +"oklch(110 110 380 / 0)", "oklch(110 110 20 / 0)", +"oklch(110% 110% 380deg / 0)", "oklch(1.1 0.44 20 / 0)", +"oklch(110 110 380 / 0.2)", "oklch(110 110 20 / 0.2)", +"oklch(110% 110% 380deg / 0.2)", "oklch(1.1 0.44 20 / 0.2)", +"oklch(110 110 380 / 1)", "oklch(110 110 20)", +"oklch(110% 110% 380deg / 1)", "oklch(1.1 0.44 20)", +"oklch(-10 110 380)", "oklch(-10 110 20)", +"oklch(-10% 110% 380deg)", "oklch(-0.1 0.44 20)", +"oklch(-10 110 380 / 0)", "oklch(-10 110 20 / 0)", +"oklch(-10% 110% 380deg / 0)", "oklch(-0.1 0.44 20 / 0)", +"oklch(-10 110 380 / 0.2)", "oklch(-10 110 20 / 0.2)", +"oklch(-10% 110% 380deg / 0.2)", "oklch(-0.1 0.44 20 / 0.2)", +"oklch(-10 110 380 / 1)", "oklch(-10 110 20)", +"oklch(-10% 110% 380deg / 1)", "oklch(-0.1 0.44 20)", +"oklch(0 -10 380)", "oklch(0 -10 20)", +"oklch(0% -10% 380deg)", "oklch(0 -0.04 20)", +"oklch(0 -10 380 / 0)", "oklch(0 -10 20 / 0)", +"oklch(0% -10% 380deg / 0)", "oklch(0 -0.04 20 / 0)", +"oklch(0 -10 380 / 0.2)", "oklch(0 -10 20 / 0.2)", +"oklch(0% -10% 380deg / 0.2)", "oklch(0 -0.04 20 / 0.2)", +"oklch(0 -10 380 / 1)", "oklch(0 -10 20)", +"oklch(0% -10% 380deg / 1)", "oklch(0 -0.04 20)", +"oklch(10 -10 380)", "oklch(10 -10 20)", +"oklch(10% -10% 380deg)", "oklch(0.1 -0.04 20)", +"oklch(10 -10 380 / 0)", "oklch(10 -10 20 / 0)", +"oklch(10% -10% 380deg / 0)", "oklch(0.1 -0.04 20 / 0)", +"oklch(10 -10 380 / 0.2)", "oklch(10 -10 20 / 0.2)", +"oklch(10% -10% 380deg / 0.2)", "oklch(0.1 -0.04 20 / 0.2)", +"oklch(10 -10 380 / 1)", "oklch(10 -10 20)", +"oklch(10% -10% 380deg / 1)", "oklch(0.1 -0.04 20)", +"oklch(110 -10 380)", "oklch(110 -10 20)", +"oklch(110% -10% 380deg)", "oklch(1.1 -0.04 20)", +"oklch(110 -10 380 / 0)", "oklch(110 -10 20 / 0)", +"oklch(110% -10% 380deg / 0)", "oklch(1.1 -0.04 20 / 0)", +"oklch(110 -10 380 / 0.2)", "oklch(110 -10 20 / 0.2)", +"oklch(110% -10% 380deg / 0.2)", "oklch(1.1 -0.04 20 / 0.2)", +"oklch(110 -10 380 / 1)", "oklch(110 -10 20)", +"oklch(110% -10% 380deg / 1)", "oklch(1.1 -0.04 20)", +"oklch(-10 -10 380)", "oklch(-10 -10 20)", +"oklch(-10% -10% 380deg)", "oklch(-0.1 -0.04 20)", +"oklch(-10 -10 380 / 0)", "oklch(-10 -10 20 / 0)", +"oklch(-10% -10% 380deg / 0)", "oklch(-0.1 -0.04 20 / 0)", +"oklch(-10 -10 380 / 0.2)", "oklch(-10 -10 20 / 0.2)", +"oklch(-10% -10% 380deg / 0.2)", "oklch(-0.1 -0.04 20 / 0.2)", +"oklch(-10 -10 380 / 1)", "oklch(-10 -10 20)", +"oklch(-10% -10% 380deg / 1)", "oklch(-0.1 -0.04 20)", +"oklch(0 0 700)", "oklch(0 0 340)", +"oklch(0% 0% 700deg)", "oklch(0 0 340)", +"oklch(0 0 700 / 0)", "oklch(0 0 340 / 0)", +"oklch(0% 0% 700deg / 0)", "oklch(0 0 340 / 0)", +"oklch(0 0 700 / 0.2)", "oklch(0 0 340 / 0.2)", +"oklch(0% 0% 700deg / 0.2)", "oklch(0 0 340 / 0.2)", +"oklch(0 0 700 / 1)", "oklch(0 0 340)", +"oklch(0% 0% 700deg / 1)", "oklch(0 0 340)", +"oklch(10 0 700)", "oklch(10 0 340)", +"oklch(10% 0% 700deg)", "oklch(0.1 0 340)", +"oklch(10 0 700 / 0)", "oklch(10 0 340 / 0)", +"oklch(10% 0% 700deg / 0)", "oklch(0.1 0 340 / 0)", +"oklch(10 0 700 / 0.2)", "oklch(10 0 340 / 0.2)", +"oklch(10% 0% 700deg / 0.2)", "oklch(0.1 0 340 / 0.2)", +"oklch(10 0 700 / 1)", "oklch(10 0 340)", +"oklch(10% 0% 700deg / 1)", "oklch(0.1 0 340)", +"oklch(110 0 700)", "oklch(110 0 340)", +"oklch(110% 0% 700deg)", "oklch(1.1 0 340)", +"oklch(110 0 700 / 0)", "oklch(110 0 340 / 0)", +"oklch(110% 0% 700deg / 0)", "oklch(1.1 0 340 / 0)", +"oklch(110 0 700 / 0.2)", "oklch(110 0 340 / 0.2)", +"oklch(110% 0% 700deg / 0.2)", "oklch(1.1 0 340 / 0.2)", +"oklch(110 0 700 / 1)", "oklch(110 0 340)", +"oklch(110% 0% 700deg / 1)", "oklch(1.1 0 340)", +"oklch(-10 0 700)", "oklch(-10 0 340)", +"oklch(-10% 0% 700deg)", "oklch(-0.1 0 340)", +"oklch(-10 0 700 / 0)", "oklch(-10 0 340 / 0)", +"oklch(-10% 0% 700deg / 0)", "oklch(-0.1 0 340 / 0)", +"oklch(-10 0 700 / 0.2)", "oklch(-10 0 340 / 0.2)", +"oklch(-10% 0% 700deg / 0.2)", "oklch(-0.1 0 340 / 0.2)", +"oklch(-10 0 700 / 1)", "oklch(-10 0 340)", +"oklch(-10% 0% 700deg / 1)", "oklch(-0.1 0 340)", +"oklch(0 10 700)", "oklch(0 10 340)", +"oklch(0% 10% 700deg)", "oklch(0 0.04 340)", +"oklch(0 10 700 / 0)", "oklch(0 10 340 / 0)", +"oklch(0% 10% 700deg / 0)", "oklch(0 0.04 340 / 0)", +"oklch(0 10 700 / 0.2)", "oklch(0 10 340 / 0.2)", +"oklch(0% 10% 700deg / 0.2)", "oklch(0 0.04 340 / 0.2)", +"oklch(0 10 700 / 1)", "oklch(0 10 340)", +"oklch(0% 10% 700deg / 1)", "oklch(0 0.04 340)", +"oklch(10 10 700)", "oklch(10 10 340)", +"oklch(10% 10% 700deg)", "oklch(0.1 0.04 340)", +"oklch(10 10 700 / 0)", "oklch(10 10 340 / 0)", +"oklch(10% 10% 700deg / 0)", "oklch(0.1 0.04 340 / 0)", +"oklch(10 10 700 / 0.2)", "oklch(10 10 340 / 0.2)", +"oklch(10% 10% 700deg / 0.2)", "oklch(0.1 0.04 340 / 0.2)", +"oklch(10 10 700 / 1)", "oklch(10 10 340)", +"oklch(10% 10% 700deg / 1)", "oklch(0.1 0.04 340)", +"oklch(110 10 700)", "oklch(110 10 340)", +"oklch(110% 10% 700deg)", "oklch(1.1 0.04 340)", +"oklch(110 10 700 / 0)", "oklch(110 10 340 / 0)", +"oklch(110% 10% 700deg / 0)", "oklch(1.1 0.04 340 / 0)", +"oklch(110 10 700 / 0.2)", "oklch(110 10 340 / 0.2)", +"oklch(110% 10% 700deg / 0.2)", "oklch(1.1 0.04 340 / 0.2)", +"oklch(110 10 700 / 1)", "oklch(110 10 340)", +"oklch(110% 10% 700deg / 1)", "oklch(1.1 0.04 340)", +"oklch(-10 10 700)", "oklch(-10 10 340)", +"oklch(-10% 10% 700deg)", "oklch(-0.1 0.04 340)", +"oklch(-10 10 700 / 0)", "oklch(-10 10 340 / 0)", +"oklch(-10% 10% 700deg / 0)", "oklch(-0.1 0.04 340 / 0)", +"oklch(-10 10 700 / 0.2)", "oklch(-10 10 340 / 0.2)", +"oklch(-10% 10% 700deg / 0.2)", "oklch(-0.1 0.04 340 / 0.2)", +"oklch(-10 10 700 / 1)", "oklch(-10 10 340)", +"oklch(-10% 10% 700deg / 1)", "oklch(-0.1 0.04 340)", +"oklch(0 110 700)", "oklch(0 110 340)", +"oklch(0% 110% 700deg)", "oklch(0 0.44 340)", +"oklch(0 110 700 / 0)", "oklch(0 110 340 / 0)", +"oklch(0% 110% 700deg / 0)", "oklch(0 0.44 340 / 0)", +"oklch(0 110 700 / 0.2)", "oklch(0 110 340 / 0.2)", +"oklch(0% 110% 700deg / 0.2)", "oklch(0 0.44 340 / 0.2)", +"oklch(0 110 700 / 1)", "oklch(0 110 340)", +"oklch(0% 110% 700deg / 1)", "oklch(0 0.44 340)", +"oklch(10 110 700)", "oklch(10 110 340)", +"oklch(10% 110% 700deg)", "oklch(0.1 0.44 340)", +"oklch(10 110 700 / 0)", "oklch(10 110 340 / 0)", +"oklch(10% 110% 700deg / 0)", "oklch(0.1 0.44 340 / 0)", +"oklch(10 110 700 / 0.2)", "oklch(10 110 340 / 0.2)", +"oklch(10% 110% 700deg / 0.2)", "oklch(0.1 0.44 340 / 0.2)", +"oklch(10 110 700 / 1)", "oklch(10 110 340)", +"oklch(10% 110% 700deg / 1)", "oklch(0.1 0.44 340)", +"oklch(110 110 700)", "oklch(110 110 340)", +"oklch(110% 110% 700deg)", "oklch(1.1 0.44 340)", +"oklch(110 110 700 / 0)", "oklch(110 110 340 / 0)", +"oklch(110% 110% 700deg / 0)", "oklch(1.1 0.44 340 / 0)", +"oklch(110 110 700 / 0.2)", "oklch(110 110 340 / 0.2)", +"oklch(110% 110% 700deg / 0.2)", "oklch(1.1 0.44 340 / 0.2)", +"oklch(110 110 700 / 1)", "oklch(110 110 340)", +"oklch(110% 110% 700deg / 1)", "oklch(1.1 0.44 340)", +"oklch(-10 110 700)", "oklch(-10 110 340)", +"oklch(-10% 110% 700deg)", "oklch(-0.1 0.44 340)", +"oklch(-10 110 700 / 0)", "oklch(-10 110 340 / 0)", +"oklch(-10% 110% 700deg / 0)", "oklch(-0.1 0.44 340 / 0)", +"oklch(-10 110 700 / 0.2)", "oklch(-10 110 340 / 0.2)", +"oklch(-10% 110% 700deg / 0.2)", "oklch(-0.1 0.44 340 / 0.2)", +"oklch(-10 110 700 / 1)", "oklch(-10 110 340)", +"oklch(-10% 110% 700deg / 1)", "oklch(-0.1 0.44 340)", +"oklch(0 -10 700)", "oklch(0 -10 340)", +"oklch(0% -10% 700deg)", "oklch(0 -0.04 340)", +"oklch(0 -10 700 / 0)", "oklch(0 -10 340 / 0)", +"oklch(0% -10% 700deg / 0)", "oklch(0 -0.04 340 / 0)", +"oklch(0 -10 700 / 0.2)", "oklch(0 -10 340 / 0.2)", +"oklch(0% -10% 700deg / 0.2)", "oklch(0 -0.04 340 / 0.2)", +"oklch(0 -10 700 / 1)", "oklch(0 -10 340)", +"oklch(0% -10% 700deg / 1)", "oklch(0 -0.04 340)", +"oklch(10 -10 700)", "oklch(10 -10 340)", +"oklch(10% -10% 700deg)", "oklch(0.1 -0.04 340)", +"oklch(10 -10 700 / 0)", "oklch(10 -10 340 / 0)", +"oklch(10% -10% 700deg / 0)", "oklch(0.1 -0.04 340 / 0)", +"oklch(10 -10 700 / 0.2)", "oklch(10 -10 340 / 0.2)", +"oklch(10% -10% 700deg / 0.2)", "oklch(0.1 -0.04 340 / 0.2)", +"oklch(10 -10 700 / 1)", "oklch(10 -10 340)", +"oklch(10% -10% 700deg / 1)", "oklch(0.1 -0.04 340)", +"oklch(110 -10 700)", "oklch(110 -10 340)", +"oklch(110% -10% 700deg)", "oklch(1.1 -0.04 340)", +"oklch(110 -10 700 / 0)", "oklch(110 -10 340 / 0)", +"oklch(110% -10% 700deg / 0)", "oklch(1.1 -0.04 340 / 0)", +"oklch(110 -10 700 / 0.2)", "oklch(110 -10 340 / 0.2)", +"oklch(110% -10% 700deg / 0.2)", "oklch(1.1 -0.04 340 / 0.2)", +"oklch(110 -10 700 / 1)", "oklch(110 -10 340)", +"oklch(110% -10% 700deg / 1)", "oklch(1.1 -0.04 340)", +"oklch(-10 -10 700)", "oklch(-10 -10 340)", +"oklch(-10% -10% 700deg)", "oklch(-0.1 -0.04 340)", +"oklch(-10 -10 700 / 0)", "oklch(-10 -10 340 / 0)", +"oklch(-10% -10% 700deg / 0)", "oklch(-0.1 -0.04 340 / 0)", +"oklch(-10 -10 700 / 0.2)", "oklch(-10 -10 340 / 0.2)", +"oklch(-10% -10% 700deg / 0.2)", "oklch(-0.1 -0.04 340 / 0.2)", +"oklch(-10 -10 700 / 1)", "oklch(-10 -10 340)", +"oklch(-10% -10% 700deg / 1)", "oklch(-0.1 -0.04 340)", +"oklch(0 0 -20)", "oklch(0 0 340)", +"oklch(0% 0% -20deg)", "oklch(0 0 340)", +"oklch(0 0 -20 / 0)", "oklch(0 0 340 / 0)", +"oklch(0% 0% -20deg / 0)", "oklch(0 0 340 / 0)", +"oklch(0 0 -20 / 0.2)", "oklch(0 0 340 / 0.2)", +"oklch(0% 0% -20deg / 0.2)", "oklch(0 0 340 / 0.2)", +"oklch(0 0 -20 / 1)", "oklch(0 0 340)", +"oklch(0% 0% -20deg / 1)", "oklch(0 0 340)", +"oklch(10 0 -20)", "oklch(10 0 340)", +"oklch(10% 0% -20deg)", "oklch(0.1 0 340)", +"oklch(10 0 -20 / 0)", "oklch(10 0 340 / 0)", +"oklch(10% 0% -20deg / 0)", "oklch(0.1 0 340 / 0)", +"oklch(10 0 -20 / 0.2)", "oklch(10 0 340 / 0.2)", +"oklch(10% 0% -20deg / 0.2)", "oklch(0.1 0 340 / 0.2)", +"oklch(10 0 -20 / 1)", "oklch(10 0 340)", +"oklch(10% 0% -20deg / 1)", "oklch(0.1 0 340)", +"oklch(110 0 -20)", "oklch(110 0 340)", +"oklch(110% 0% -20deg)", "oklch(1.1 0 340)", +"oklch(110 0 -20 / 0)", "oklch(110 0 340 / 0)", +"oklch(110% 0% -20deg / 0)", "oklch(1.1 0 340 / 0)", +"oklch(110 0 -20 / 0.2)", "oklch(110 0 340 / 0.2)", +"oklch(110% 0% -20deg / 0.2)", "oklch(1.1 0 340 / 0.2)", +"oklch(110 0 -20 / 1)", "oklch(110 0 340)", +"oklch(110% 0% -20deg / 1)", "oklch(1.1 0 340)", +"oklch(-10 0 -20)", "oklch(-10 0 340)", +"oklch(-10% 0% -20deg)", "oklch(-0.1 0 340)", +"oklch(-10 0 -20 / 0)", "oklch(-10 0 340 / 0)", +"oklch(-10% 0% -20deg / 0)", "oklch(-0.1 0 340 / 0)", +"oklch(-10 0 -20 / 0.2)", "oklch(-10 0 340 / 0.2)", +"oklch(-10% 0% -20deg / 0.2)", "oklch(-0.1 0 340 / 0.2)", +"oklch(-10 0 -20 / 1)", "oklch(-10 0 340)", +"oklch(-10% 0% -20deg / 1)", "oklch(-0.1 0 340)", +"oklch(0 10 -20)", "oklch(0 10 340)", +"oklch(0% 10% -20deg)", "oklch(0 0.04 340)", +"oklch(0 10 -20 / 0)", "oklch(0 10 340 / 0)", +"oklch(0% 10% -20deg / 0)", "oklch(0 0.04 340 / 0)", +"oklch(0 10 -20 / 0.2)", "oklch(0 10 340 / 0.2)", +"oklch(0% 10% -20deg / 0.2)", "oklch(0 0.04 340 / 0.2)", +"oklch(0 10 -20 / 1)", "oklch(0 10 340)", +"oklch(0% 10% -20deg / 1)", "oklch(0 0.04 340)", +"oklch(10 10 -20)", "oklch(10 10 340)", +"oklch(10% 10% -20deg)", "oklch(0.1 0.04 340)", +"oklch(10 10 -20 / 0)", "oklch(10 10 340 / 0)", +"oklch(10% 10% -20deg / 0)", "oklch(0.1 0.04 340 / 0)", +"oklch(10 10 -20 / 0.2)", "oklch(10 10 340 / 0.2)", +"oklch(10% 10% -20deg / 0.2)", "oklch(0.1 0.04 340 / 0.2)", +"oklch(10 10 -20 / 1)", "oklch(10 10 340)", +"oklch(10% 10% -20deg / 1)", "oklch(0.1 0.04 340)", +"oklch(110 10 -20)", "oklch(110 10 340)", +"oklch(110% 10% -20deg)", "oklch(1.1 0.04 340)", +"oklch(110 10 -20 / 0)", "oklch(110 10 340 / 0)", +"oklch(110% 10% -20deg / 0)", "oklch(1.1 0.04 340 / 0)", +"oklch(110 10 -20 / 0.2)", "oklch(110 10 340 / 0.2)", +"oklch(110% 10% -20deg / 0.2)", "oklch(1.1 0.04 340 / 0.2)", +"oklch(110 10 -20 / 1)", "oklch(110 10 340)", +"oklch(110% 10% -20deg / 1)", "oklch(1.1 0.04 340)", +"oklch(-10 10 -20)", "oklch(-10 10 340)", +"oklch(-10% 10% -20deg)", "oklch(-0.1 0.04 340)", +"oklch(-10 10 -20 / 0)", "oklch(-10 10 340 / 0)", +"oklch(-10% 10% -20deg / 0)", "oklch(-0.1 0.04 340 / 0)", +"oklch(-10 10 -20 / 0.2)", "oklch(-10 10 340 / 0.2)", +"oklch(-10% 10% -20deg / 0.2)", "oklch(-0.1 0.04 340 / 0.2)", +"oklch(-10 10 -20 / 1)", "oklch(-10 10 340)", +"oklch(-10% 10% -20deg / 1)", "oklch(-0.1 0.04 340)", +"oklch(0 110 -20)", "oklch(0 110 340)", +"oklch(0% 110% -20deg)", "oklch(0 0.44 340)", +"oklch(0 110 -20 / 0)", "oklch(0 110 340 / 0)", +"oklch(0% 110% -20deg / 0)", "oklch(0 0.44 340 / 0)", +"oklch(0 110 -20 / 0.2)", "oklch(0 110 340 / 0.2)", +"oklch(0% 110% -20deg / 0.2)", "oklch(0 0.44 340 / 0.2)", +"oklch(0 110 -20 / 1)", "oklch(0 110 340)", +"oklch(0% 110% -20deg / 1)", "oklch(0 0.44 340)", +"oklch(10 110 -20)", "oklch(10 110 340)", +"oklch(10% 110% -20deg)", "oklch(0.1 0.44 340)", +"oklch(10 110 -20 / 0)", "oklch(10 110 340 / 0)", +"oklch(10% 110% -20deg / 0)", "oklch(0.1 0.44 340 / 0)", +"oklch(10 110 -20 / 0.2)", "oklch(10 110 340 / 0.2)", +"oklch(10% 110% -20deg / 0.2)", "oklch(0.1 0.44 340 / 0.2)", +"oklch(10 110 -20 / 1)", "oklch(10 110 340)", +"oklch(10% 110% -20deg / 1)", "oklch(0.1 0.44 340)", +"oklch(110 110 -20)", "oklch(110 110 340)", +"oklch(110% 110% -20deg)", "oklch(1.1 0.44 340)", +"oklch(110 110 -20 / 0)", "oklch(110 110 340 / 0)", +"oklch(110% 110% -20deg / 0)", "oklch(1.1 0.44 340 / 0)", +"oklch(110 110 -20 / 0.2)", "oklch(110 110 340 / 0.2)", +"oklch(110% 110% -20deg / 0.2)", "oklch(1.1 0.44 340 / 0.2)", +"oklch(110 110 -20 / 1)", "oklch(110 110 340)", +"oklch(110% 110% -20deg / 1)", "oklch(1.1 0.44 340)", +"oklch(-10 110 -20)", "oklch(-10 110 340)", +"oklch(-10% 110% -20deg)", "oklch(-0.1 0.44 340)", +"oklch(-10 110 -20 / 0)", "oklch(-10 110 340 / 0)", +"oklch(-10% 110% -20deg / 0)", "oklch(-0.1 0.44 340 / 0)", +"oklch(-10 110 -20 / 0.2)", "oklch(-10 110 340 / 0.2)", +"oklch(-10% 110% -20deg / 0.2)", "oklch(-0.1 0.44 340 / 0.2)", +"oklch(-10 110 -20 / 1)", "oklch(-10 110 340)", +"oklch(-10% 110% -20deg / 1)", "oklch(-0.1 0.44 340)", +"oklch(0 -10 -20)", "oklch(0 -10 340)", +"oklch(0% -10% -20deg)", "oklch(0 -0.04 340)", +"oklch(0 -10 -20 / 0)", "oklch(0 -10 340 / 0)", +"oklch(0% -10% -20deg / 0)", "oklch(0 -0.04 340 / 0)", +"oklch(0 -10 -20 / 0.2)", "oklch(0 -10 340 / 0.2)", +"oklch(0% -10% -20deg / 0.2)", "oklch(0 -0.04 340 / 0.2)", +"oklch(0 -10 -20 / 1)", "oklch(0 -10 340)", +"oklch(0% -10% -20deg / 1)", "oklch(0 -0.04 340)", +"oklch(10 -10 -20)", "oklch(10 -10 340)", +"oklch(10% -10% -20deg)", "oklch(0.1 -0.04 340)", +"oklch(10 -10 -20 / 0)", "oklch(10 -10 340 / 0)", +"oklch(10% -10% -20deg / 0)", "oklch(0.1 -0.04 340 / 0)", +"oklch(10 -10 -20 / 0.2)", "oklch(10 -10 340 / 0.2)", +"oklch(10% -10% -20deg / 0.2)", "oklch(0.1 -0.04 340 / 0.2)", +"oklch(10 -10 -20 / 1)", "oklch(10 -10 340)", +"oklch(10% -10% -20deg / 1)", "oklch(0.1 -0.04 340)", +"oklch(110 -10 -20)", "oklch(110 -10 340)", +"oklch(110% -10% -20deg)", "oklch(1.1 -0.04 340)", +"oklch(110 -10 -20 / 0)", "oklch(110 -10 340 / 0)", +"oklch(110% -10% -20deg / 0)", "oklch(1.1 -0.04 340 / 0)", +"oklch(110 -10 -20 / 0.2)", "oklch(110 -10 340 / 0.2)", +"oklch(110% -10% -20deg / 0.2)", "oklch(1.1 -0.04 340 / 0.2)", +"oklch(110 -10 -20 / 1)", "oklch(110 -10 340)", +"oklch(110% -10% -20deg / 1)", "oklch(1.1 -0.04 340)", +"oklch(-10 -10 -20)", "oklch(-10 -10 340)", +"oklch(-10% -10% -20deg)", "oklch(-0.1 -0.04 340)", +"oklch(-10 -10 -20 / 0)", "oklch(-10 -10 340 / 0)", +"oklch(-10% -10% -20deg / 0)", "oklch(-0.1 -0.04 340 / 0)", +"oklch(-10 -10 -20 / 0.2)", "oklch(-10 -10 340 / 0.2)", +"oklch(-10% -10% -20deg / 0.2)", "oklch(-0.1 -0.04 340 / 0.2)", +"oklch(-10 -10 -20 / 1)", "oklch(-10 -10 340)", +"oklch(-10% -10% -20deg / 1)", "oklch(-0.1 -0.04 340)" +]
diff --git a/src/css-parsing-tests/component_value_list.json b/src/css-parsing-tests/component_value_list.json new file mode 100644 index 0000000..ed26e12 --- /dev/null +++ b/src/css-parsing-tests/component_value_list.json
@@ -0,0 +1,373 @@ +[ + +"", [], + +"/*/*///** /* **/*//* ", [ + "/", "*", "/" +], + +"red", [ + ["ident", "red"] +], + +" \t\t\r\n\nRed ", [ + " ", ["ident", "Red"], " " +], + +"red/* CDC */-->", [ + ["ident", "red"], "-->" +], + +"red-->/* Not CDC */", [ + ["ident", "red--"], ">" +], + +"\\- red0 -red --red -\\-red\\ blue 0red -0red \u0000\\\u0000red _Red .red rêd r\\êd \u007F\u0080\u0081", [ + ["ident", "-"], " ", + ["ident", "red0"], " ", + ["ident", "-red"], " ", + ["ident", "--red"], " ", + ["ident", "--red blue"], " ", + ["dimension", "0", 0, "integer", "red"], " ", + ["dimension", "-0", 0, "integer", "red"], " ", + ["ident", "\uFFFD\uFFFDred"], " ", + ["ident", "_Red"], " ", + ".", ["ident", "red"], " ", + ["ident", "rêd"], " ", + ["ident", "rêd"], " ", + "\u007F", ["ident", "\u0080\u0081"] +], + +"\\30red \\00030 red \\30\r\nred \\0000000red \\1100000red \\red \\r ed \\.red \\ red \\\nred \\376\\37 6\\000376\\0000376\\", [ + ["ident", "0red"], " ", + ["ident", "0red"], " ", + ["ident", "0red"], " ", + ["ident", "\uFFFD0red"], " ", + ["ident", "\uFFFD0red"], " ", + ["ident", "red"], " ", + ["ident", "r"], " ", ["ident", "ed"], " ", + ["ident", ".red"], " ", + ["ident", " red"], " ", + "\\", " ", ["ident", "red"], " ", + ["ident", "Ͷ76Ͷ76\uFFFD"] +], + +"rgba0() -rgba() --rgba() -\\-rgba() 0rgba() -0rgba() _rgba() .rgba() rgbâ() \\30rgba() rgba () @rgba() #rgba()", [ + ["function", "rgba0"], " ", + ["function", "-rgba"], " ", + ["function", "--rgba"], " ", + ["function", "--rgba"], " ", + ["dimension", "0", 0, "integer", "rgba"], ["()"], " ", + ["dimension", "-0", 0, "integer", "rgba"], ["()"], " ", + ["function", "_rgba"], " ", + ".", ["function", "rgba"], " ", + ["function", "rgbâ"], " ", + ["function", "0rgba"], " ", + ["ident", "rgba"], " ", ["()"], " ", + ["at-keyword", "rgba"], ["()"], " ", + ["hash", "rgba", "id"], ["()"] +], + +"@media0 @-Media @--media @-\\-media @0media @-0media @_media @.media @medÄ°a @\\30 media\\", [ + ["at-keyword", "media0"], " ", + ["at-keyword", "-Media"], " ", + ["at-keyword", "--media"], " ", + ["at-keyword", "--media"], " ", + "@", ["dimension", "0", 0, "integer", "media"], " ", + "@", ["dimension", "-0", 0, "integer", "media"], " ", + ["at-keyword", "_media"], " ", + "@", ".", ["ident", "media"], " ", + ["at-keyword", "medÄ°a"], " ", + ["at-keyword", "0media\uFFFD"] +], + +"#red0 #-Red #--red #-\\-red #0red #-0red #_Red #.red #rêd #êrd #\\.red\\", [ + ["hash", "red0", "id"], " ", + ["hash", "-Red", "id"], " ", + ["hash", "--red", "id"], " ", + ["hash", "--red", "id"], " ", + ["hash", "0red", "unrestricted"], " ", + ["hash", "-0red", "unrestricted"], " ", + ["hash", "_Red", "id"], " ", + "#", ".", ["ident", "red"], " ", + ["hash", "rêd", "id"], " ", + ["hash", "êrd", "id"], " ", + ["hash", ".red\uFFFD", "id"] +], + +"p[example=\"\\\nfoo(int x) {\\\n this.x = x;\\\n}\\\n\"]", [ + ["ident", "p"], ["[]", + ["ident", "example"], "=", ["string", "foo(int x) { this.x = x;}"] + ] +], + +"'' 'Lorem \"îpsum\"' 'a\\\nb' 'a\nb 'eof", [ + ["string", ""], " ", + ["string", "Lorem \"îpsum\""], " ", + ["string", "ab"], " ", + ["error", "bad-string"], " ", ["ident", "b"], " ", + ["string", "eof"] +], + +"\"\" \"Lorem 'îpsum'\" \"a\\\nb\" \"a\nb \"eof", [ + ["string", ""], " ", + ["string", "Lorem 'îpsum'"], " ", + ["string", "ab"], " ", + ["error", "bad-string"], " ", ["ident", "b"], " ", + ["string", "eof"] +], + +"\"Lo\\rem \\130 ps\\u m\" '\\376\\37 6\\000376\\0000376\\", [ + ["string", "Lorem Ä°psu m"], " ", + ["string", "Ͷ76Ͷ76"] +], + +"url( '') url('Lorem \"îpsum\"'\n) url('a\\\nb' ) url('a\nb) url('eof", [ + ["function", "url", " ", ["string", ""]], " ", + ["function", "url", ["string", "Lorem \"îpsum\""], " "], " ", + ["function", "url", ["string", "ab"], " "], " ", + ["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ", + ["function", "url", ["string", "eof"]] +], + +"url(", [ + ["url", ""] +], + +"url( \t", [ + ["url", ""] +], + +"url(\"\") url(\"Lorem 'îpsum'\"\n) url(\"a\\\nb\" ) url(\"a\nb) url(\"eof", [ + ["function", "url", ["string", ""]], " ", + ["function", "url", ["string", "Lorem 'îpsum'"], " "], " ", + ["function", "url", ["string", "ab"], " "], " ", + ["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ", + ["function", "url", ["string", "eof"]] +], + +"url(\"Lo\\rem \\130 ps\\u m\") url('\\376\\37 6\\000376\\0000376\\", [ + ["function", "url", ["string", "Lorem Ä°psu m"]], " ", + ["function", "url", ["string", "Ͷ76Ͷ76"]] +], + +"URL(foo) Url(foo) ûrl(foo) url (foo) url\\ (foo) url(\t 'foo' ", [ + ["url", "foo"], " ", + ["url", "foo"], " ", + ["function", "ûrl", ["ident", "foo"]], " ", + ["ident", "url"], " ", ["()", ["ident", "foo"]], " ", + ["function", "url ", ["ident", "foo"]], " ", + ["function", "url", " ", ["string", "foo"], " "] +], + +"url('a' b) url('c' d)", [ + ["function", "url", ["string", "a"], " ", ["ident", "b"]], " ", + ["function", "url", ["string", "c"], " ", ["ident", "d"]] +], + +"url('a\nb) url('c\n", [ + ["function", "url", ["error", "bad-string"], " ", ["ident", "b"]], " ", + ["function", "url", ["error", "bad-string"], " "] +], + +"url() url( \t) url(\n Foô\\030\n!\n) url(\na\nb\n) url(a\\ b) url(a(b) url(a\\(b) url(a'b) url(a\\'b) url(a\"b) url(a\\\"b) url(a\nb) url(a\\\nb) url(a\\a b) url(a\\", [ + ["url", ""], " ", + ["url", ""], " ", + ["url", "Foô0!"], " ", + ["error", "bad-url"], " ", + ["url", "a b"], " ", + ["error", "bad-url"], " ", + ["url", "a(b"], " ", + ["error", "bad-url"], " ", + ["url", "a'b"], " ", + ["error", "bad-url"], " ", + ["url", "a\"b"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["url", "a\nb"], " ", + ["url", "a\uFFFD"] +], + +"url(\u0000!#$%&*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0080\u0081\u009e\u009f\u00a0\u00a1\u00a2", [ + ["url", "\uFFFD!#$%&*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0080\u0081\u009e\u009f\u00a0¡¢"] +], + +"url(\u0001) url(\u0002) url(\u0003) url(\u0004) url(\u0005) url(\u0006) url(\u0007) url(\u0008) url(\u000b) url(\u000e) url(\u000f) url(\u0010) url(\u0011) url(\u0012) url(\u0013) url(\u0014) url(\u0015) url(\u0016) url(\u0017) url(\u0018) url(\u0019) url(\u001a) url(\u001b) url(\u001c) url(\u001d) url(\u001e) url(\u001f) url(\u007f)", [ + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"], " ", + ["error", "bad-url"] +], + +"12 +34 -45 .67 +.89 -.01 2.3 +45.0 -0.67", [ + ["number", "12", 12, "integer"], " ", + ["number", "+34", 34, "integer"], " ", + ["number", "-45", -45, "integer"], " ", + ["number", "0.67", 0.67, "number"], " ", + ["number", "+0.89", 0.89, "number"], " ", + ["number", "-0.01", -0.01, "number"], " ", + ["number", "2.3", 2.3, "number"], " ", + ["number", "+45.0", 45, "number"], " ", + ["number", "-0.67", -0.67, "number"] +], + +"12e2 +34e+1 -45E-0 .68e+3 +.79e-1 -.01E2 2.3E+1 +45.0e6 -0.67e0", [ + ["number", "1200.0", 1200, "number"], " ", + ["number", "+340.0", 340, "number"], " ", + ["number", "-45.0", -45, "number"], " ", + ["number", "680.0", 680, "number"], " ", + ["number", "+0.079", 0.079, "number"], " ", + ["number", "-1.0", -1, "number"], " ", + ["number", "23.0", 23, "number"], " ", + ["number", "+45000000.0", 45000000, "number"], " ", + ["number", "-0.67", -0.67, "number"] +], + +"12.3e30 -0.0123e30 9999e-13", [ + ["number", "1.23e31", 1.23e31, "number"], " ", + ["number", "-1.23e28", -1.23e28, "number"], " ", + ["number", "9.999e-10", 9.999e-10, "number"] +], + +"3. /* Decimal point must have following digits */", [ + ["number", "3", 3, "integer"], ".", " " +], + +"3\\65-2 /* Scientific notation E can not be escaped */", [ + ["dimension", "3", 3, "integer", "e-2"], " " +], + +"3e-2.1 /* Integer exponents only */", [ + ["number", "0.03", 0.03, "number"], + ["number", "0.1", 0.1, "number"], " " +], + +"12% +34% -45% .67% +.89% -.01% 2.3% +45.0% -0.67%", [ + ["percentage", "12", 12, "integer"], " ", + ["percentage", "+34", 34, "integer"], " ", + ["percentage", "-45", -45, "integer"], " ", + ["percentage", "0.67", 0.67, "number"], " ", + ["percentage", "+0.89", 0.89, "number"], " ", + ["percentage", "-0.01", -0.01, "number"], " ", + ["percentage", "2.3", 2.3000000000, "number"], " ", + ["percentage", "+45.0", 45.0, "number"], " ", + ["percentage", "-0.67", -0.67, "number"] +], + +"12e2% +34e+1% -45E-0% .68e+3% +.79e-1% -.01E2% 2.3E+1% +45.0e6% -0.67e0%", [ + ["percentage", "1200.0", 1200, "number"], " ", + ["percentage", "+340.0", 340, "number"], " ", + ["percentage", "-45.0", -45, "number"], " ", + ["percentage", "680.0", 680, "number"], " ", + ["percentage", "+0.079", 0.079, "number"], " ", + ["percentage", "-1.0", -1, "number"], " ", + ["percentage", "23.0", 23, "number"], " ", + ["percentage", "+45000000.0", 45000000, "number"], " ", + ["percentage", "-0.67", -0.67, "number"] +], + +"12\\% /* Percent sign can not be escaped */", [ + ["dimension", "12", 12, "integer", "%"], " " +], + +"12px +34px -45px .67px +.89px -.01px 2.3px +45.0px -0.67px", [ + ["dimension", "12", 12, "integer", "px"], " ", + ["dimension", "+34", 34, "integer", "px"], " ", + ["dimension", "-45", -45, "integer", "px"], " ", + ["dimension", "0.67", 0.67, "number", "px"], " ", + ["dimension", "+0.89", 0.89, "number", "px"], " ", + ["dimension", "-0.01", -0.01, "number", "px"], " ", + ["dimension", "2.3", 2.3, "number", "px"], " ", + ["dimension", "+45.0", 45, "number", "px"], " ", + ["dimension", "-0.67", -0.67, "number", "px"] +], + +"12e2px +34e+1px -45E-0px .68e+3px +.79e-1px -.01E2px 2.3E+1px +45.0e6px -0.67e0px", [ + ["dimension", "1200.0", 1200, "number", "px"], " ", + ["dimension", "+340.0", 340, "number", "px"], " ", + ["dimension", "-45.0", -45, "number", "px"], " ", + ["dimension", "680.0", 680, "number", "px"], " ", + ["dimension", "+0.079", 0.079, "number", "px"], " ", + ["dimension", "-1.0", -1, "number", "px"], " ", + ["dimension", "23.0", 23, "number", "px"], " ", + ["dimension", "+45000000.0", 45000000, "number", "px"], " ", + ["dimension", "-0.67", -0.67, "number", "px"] +], + +"12red0 12.0-red 12--red 12-\\-red 120red 12-0red 12\u0000red 12_Red 12.red 12rêd", [ + ["dimension", "12", 12, "integer", "red0"], " ", + ["dimension", "12.0", 12, "number", "-red"], " ", + ["dimension", "12", 12, "integer", "--red"], " ", + ["dimension", "12", 12, "integer", "--red"], " ", + ["dimension", "120", 120, "integer", "red"], " ", + ["number", "12", 12, "integer"], ["dimension", "-0", 0, "integer", "red"], " ", + ["dimension", "12", 12, "integer", "\uFFFDred"], " ", + ["dimension", "12", 12, "integer", "_Red"], " ", + ["number", "12", 12, "integer"], ".", ["ident", "red"], " ", + ["dimension", "12", 12, "integer", "rêd"] +], + +"~=|=^=$=*=||<!------> |/**/| ~/**/=", [ + "~=", "|=", "^=", "$=", "*=", "|", "|", "<!--", ["ident", "----"], ">", + " ", "|", "|", " ", "~", "=" +], + +"a:not([href^=http\\:], [href ^=\t'https\\:'\n]) { color: rgba(0%, 100%, 50%); }", [ + ["ident", "a"], ":", ["function", "not", + ["[]", + ["ident", "href"], "^=", ["ident", "http:"] + ], ",", " ", ["[]", + ["ident", "href"], " ", "^=", " ", ["string", "https:"], " " + ] + ], " ", ["{}", + " ", ["ident", "color"], ":", " ", ["function", "rgba", + ["percentage", "0", 0, "integer"], ",", " ", + ["percentage", "100", 100, "integer"], ",", " ", + ["percentage", "50", 50, "integer"] + ], ";", " " + ] +], + +"@media print { (foo]{bar) }baz", [ + ["at-keyword", "media"], " ", ["ident", "print"], " ", ["{}", + " ", ["()", + ["ident", "foo"], ["error", "]"], ["{}", + ["ident", "bar"], ["error", ")"], " " + ], ["ident", "baz"] + ] + ] +], + +"4/**/%", [ + ["number", "4", 4, "integer"], "%" +], + +"-/**/%", [ "-", "%"], + +"#/**/%", [ "#", "%"] + +]
diff --git a/src/css-parsing-tests/declaration_list.json b/src/css-parsing-tests/declaration_list.json new file mode 100644 index 0000000..abd2304 --- /dev/null +++ b/src/css-parsing-tests/declaration_list.json
@@ -0,0 +1,58 @@ +[ + +"", [], +";; /**/ ; ;", [], +"a:b; c:d 42!important;\n", [ + ["declaration", "a", [["ident", "b"]], false], + ["declaration", "c", [["ident", "d"], " ", ["number", "42", 42, "integer"]], true] +], + +"z;a:b", [ + ["error", "invalid"], + ["declaration", "a", [["ident", "b"]], false] +], + +"z:x!;a:b", [ + ["declaration", "z", [["ident", "x"], "!"], false], + ["declaration", "a", [["ident", "b"]], false] +], + +"a:b; c+:d", [ + ["declaration", "a", [["ident", "b"]], false], + ["error", "invalid"] +], + +"@import 'foo.css'; a:b/**/; @import 'bar.css'", [ + ["at-rule", "import", [" ", ["string", "foo.css"]], null], + ["declaration", "a", [["ident", "b"]], false], + ["at-rule", "import", [" ", ["string", "bar.css"]], null] +], + +"@media screen { div{;}} a:b;; @media print{div{", [ + ["at-rule", "media", [" ", ["ident", "screen"], " "], [" ", ["ident", "div"], ["{}", ";"]]], + ["declaration", "a", [["ident", "b"]], false], + ["at-rule", "media", [" ", ["ident", "print"]], [["ident", "div"], ["{}"]]] +], + +"@ media screen { div{;}} a:b;; @media print{div{", [ + ["qualified rule", + ["@", " ", ["ident", "media" ], " ", [ "ident", "screen" ], " " ], + [ + " ", + [ + "ident", + "div" + ], + [ + "{}", + ";" + ] + ] + ], + ["declaration", "a", [["ident", "b"]], false], + ["at-rule", "media", [" ", ["ident", "print"]], [["ident", "div"], ["{}"]]] +], + +"", [] + +]
diff --git a/src/css-parsing-tests/make_color3_hsl.py b/src/css-parsing-tests/make_color3_hsl.py new file mode 100644 index 0000000..6ae6718 --- /dev/null +++ b/src/css-parsing-tests/make_color3_hsl.py
@@ -0,0 +1,56 @@ +import colorsys # It turns out Python already does HSL -> RGB! +import math +import re + + +def fix_rounding_error(x): + # We get rounding errors on these values. + # 127.5 sometimes rounds to 128, sometimes rounds to 127, + # so let's just brute force fix (haxX0r!1) them! + x = round(x) + if x == 127: + return 128 + return x + + +def rgba_to_str(r, g, b, a=None): + if a is None: + a = 1.0 + + r = fix_rounding_error(r * 255) + g = fix_rounding_error(g * 255) + b = fix_rounding_error(b * 255) + + if a == 1.0: + return 'rgb({:g}, {:g}, {:g})'.format(r, g, b) + else: + return 'rgba({:g}, {:g}, {:g}, {:g})'.format(r, g, b, a) + + +def trim(s): return s if not s.endswith('.0') else s[:-2] + + +print('[') +print(',\n'.join( + function_format % tuple( + [ + function_name, + hue, + trim(str(saturation / 10.)), + trim(str(lightness / 10.)), + alpha_format % round(alpha, 2) if alpha is not None else '', + rgba_to_str(*colorsys.hls_to_rgb(hue / 360., + lightness / 1000., saturation / 1000.), alpha), + ] + ) + for function_format, alpha_format in [ + ('"%s(%s, %s%%, %s%%%s)", "%s"', ', %s'), + ('"%s(%s %s%% %s%%%s)", "%s"', ' / %s') + ] + for function_name in ["hsl", "hsla"] + for alpha in [None, 1.0, 0.25, 0.0] + for lightness in range(0, 1001, 125) + for saturation in range(0, 1001, 125) + for hue in range(0, 360, 30) +)) +print(']')
diff --git a/src/css-parsing-tests/make_color3_keywords.py b/src/css-parsing-tests/make_color3_keywords.py new file mode 100644 index 0000000..d4af395 --- /dev/null +++ b/src/css-parsing-tests/make_color3_keywords.py
@@ -0,0 +1,199 @@ +all_keywords = [ + ('transparent', (0, 0, 0, 0.0)), + + ('black', (0, 0, 0, 1.0)), + ('silver', (192, 192, 192, 1.0)), + ('gray', (128, 128, 128, 1.0)), + ('white', (255, 255, 255, 1.0)), + ('maroon', (128, 0, 0, 1.0)), + ('red', (255, 0, 0, 1.0)), + ('purple', (128, 0, 128, 1.0)), + ('fuchsia', (255, 0, 255, 1.0)), + ('green', (0, 128, 0, 1.0)), + ('lime', (0, 255, 0, 1.0)), + ('olive', (128, 128, 0, 1.0)), + ('yellow', (255, 255, 0, 1.0)), + ('navy', (0, 0, 128, 1.0)), + ('blue', (0, 0, 255, 1.0)), + ('teal', (0, 128, 128, 1.0)), + ('aqua', (0, 255, 255, 1.0)), + + ('aliceblue', (240, 248, 255, 1.0)), + ('antiquewhite', (250, 235, 215, 1.0)), + ('aqua', (0, 255, 255, 1.0)), + ('aquamarine', (127, 255, 212, 1.0)), + ('azure', (240, 255, 255, 1.0)), + ('beige', (245, 245, 220, 1.0)), + ('bisque', (255, 228, 196, 1.0)), + ('black', (0, 0, 0, 1.0)), + ('blanchedalmond', (255, 235, 205, 1.0)), + ('blue', (0, 0, 255, 1.0)), + ('blueviolet', (138, 43, 226, 1.0)), + ('brown', (165, 42, 42, 1.0)), + ('burlywood', (222, 184, 135, 1.0)), + ('cadetblue', (95, 158, 160, 1.0)), + ('chartreuse', (127, 255, 0, 1.0)), + ('chocolate', (210, 105, 30, 1.0)), + ('coral', (255, 127, 80, 1.0)), + ('cornflowerblue', (100, 149, 237, 1.0)), + ('cornsilk', (255, 248, 220, 1.0)), + ('crimson', (220, 20, 60, 1.0)), + ('cyan', (0, 255, 255, 1.0)), + ('darkblue', (0, 0, 139, 1.0)), + ('darkcyan', (0, 139, 139, 1.0)), + ('darkgoldenrod', (184, 134, 11, 1.0)), + ('darkgray', (169, 169, 169, 1.0)), + ('darkgreen', (0, 100, 0, 1.0)), + ('darkgrey', (169, 169, 169, 1.0)), + ('darkkhaki', (189, 183, 107, 1.0)), + ('darkmagenta', (139, 0, 139, 1.0)), + ('darkolivegreen', (85, 107, 47, 1.0)), + ('darkorange', (255, 140, 0, 1.0)), + ('darkorchid', (153, 50, 204, 1.0)), + ('darkred', (139, 0, 0, 1.0)), + ('darksalmon', (233, 150, 122, 1.0)), + ('darkseagreen', (143, 188, 143, 1.0)), + ('darkslateblue', (72, 61, 139, 1.0)), + ('darkslategray', (47, 79, 79, 1.0)), + ('darkslategrey', (47, 79, 79, 1.0)), + ('darkturquoise', (0, 206, 209, 1.0)), + ('darkviolet', (148, 0, 211, 1.0)), + ('deeppink', (255, 20, 147, 1.0)), + ('deepskyblue', (0, 191, 255, 1.0)), + ('dimgray', (105, 105, 105, 1.0)), + ('dimgrey', (105, 105, 105, 1.0)), + ('dodgerblue', (30, 144, 255, 1.0)), + ('firebrick', (178, 34, 34, 1.0)), + ('floralwhite', (255, 250, 240, 1.0)), + ('forestgreen', (34, 139, 34, 1.0)), + ('fuchsia', (255, 0, 255, 1.0)), + ('gainsboro', (220, 220, 220, 1.0)), + ('ghostwhite', (248, 248, 255, 1.0)), + ('gold', (255, 215, 0, 1.0)), + ('goldenrod', (218, 165, 32, 1.0)), + ('gray', (128, 128, 128, 1.0)), + ('green', (0, 128, 0, 1.0)), + ('greenyellow', (173, 255, 47, 1.0)), + ('grey', (128, 128, 128, 1.0)), + ('honeydew', (240, 255, 240, 1.0)), + ('hotpink', (255, 105, 180, 1.0)), + ('indianred', (205, 92, 92, 1.0)), + ('indigo', (75, 0, 130, 1.0)), + ('ivory', (255, 255, 240, 1.0)), + ('khaki', (240, 230, 140, 1.0)), + ('lavender', (230, 230, 250, 1.0)), + ('lavenderblush', (255, 240, 245, 1.0)), + ('lawngreen', (124, 252, 0, 1.0)), + ('lemonchiffon', (255, 250, 205, 1.0)), + ('lightblue', (173, 216, 230, 1.0)), + ('lightcoral', (240, 128, 128, 1.0)), + ('lightcyan', (224, 255, 255, 1.0)), + ('lightgoldenrodyellow', (250, 250, 210, 1.0)), + ('lightgray', (211, 211, 211, 1.0)), + ('lightgreen', (144, 238, 144, 1.0)), + ('lightgrey', (211, 211, 211, 1.0)), + ('lightpink', (255, 182, 193, 1.0)), + ('lightsalmon', (255, 160, 122, 1.0)), + ('lightseagreen', (32, 178, 170, 1.0)), + ('lightskyblue', (135, 206, 250, 1.0)), + ('lightslategray', (119, 136, 153, 1.0)), + ('lightslategrey', (119, 136, 153, 1.0)), + ('lightsteelblue', (176, 196, 222, 1.0)), + ('lightyellow', (255, 255, 224, 1.0)), + ('lime', (0, 255, 0, 1.0)), + ('limegreen', (50, 205, 50, 1.0)), + ('linen', (250, 240, 230, 1.0)), + ('magenta', (255, 0, 255, 1.0)), + ('maroon', (128, 0, 0, 1.0)), + ('mediumaquamarine', (102, 205, 170, 1.0)), + ('mediumblue', (0, 0, 205, 1.0)), + ('mediumorchid', (186, 85, 211, 1.0)), + ('mediumpurple', (147, 112, 219, 1.0)), + ('mediumseagreen', (60, 179, 113, 1.0)), + ('mediumslateblue', (123, 104, 238, 1.0)), + ('mediumspringgreen', (0, 250, 154, 1.0)), + ('mediumturquoise', (72, 209, 204, 1.0)), + ('mediumvioletred', (199, 21, 133, 1.0)), + ('midnightblue', (25, 25, 112, 1.0)), + ('mintcream', (245, 255, 250, 1.0)), + ('mistyrose', (255, 228, 225, 1.0)), + ('moccasin', (255, 228, 181, 1.0)), + ('navajowhite', (255, 222, 173, 1.0)), + ('navy', (0, 0, 128, 1.0)), + ('oldlace', (253, 245, 230, 1.0)), + ('olive', (128, 128, 0, 1.0)), + ('olivedrab', (107, 142, 35, 1.0)), + ('orange', (255, 165, 0, 1.0)), + ('orangered', (255, 69, 0, 1.0)), + ('orchid', (218, 112, 214, 1.0)), + ('palegoldenrod', (238, 232, 170, 1.0)), + ('palegreen', (152, 251, 152, 1.0)), + ('paleturquoise', (175, 238, 238, 1.0)), + ('palevioletred', (219, 112, 147, 1.0)), + ('papayawhip', (255, 239, 213, 1.0)), + ('peachpuff', (255, 218, 185, 1.0)), + ('peru', (205, 133, 63, 1.0)), + ('pink', (255, 192, 203, 1.0)), + ('plum', (221, 160, 221, 1.0)), + ('powderblue', (176, 224, 230, 1.0)), + ('purple', (128, 0, 128, 1.0)), + ('red', (255, 0, 0, 1.0)), + ('rosybrown', (188, 143, 143, 1.0)), + ('royalblue', (65, 105, 225, 1.0)), + ('saddlebrown', (139, 69, 19, 1.0)), + ('salmon', (250, 128, 114, 1.0)), + ('sandybrown', (244, 164, 96, 1.0)), + ('seagreen', (46, 139, 87, 1.0)), + ('seashell', (255, 245, 238, 1.0)), + ('sienna', (160, 82, 45, 1.0)), + ('silver', (192, 192, 192, 1.0)), + ('skyblue', (135, 206, 235, 1.0)), + ('slateblue', (106, 90, 205, 1.0)), + ('slategray', (112, 128, 144, 1.0)), + ('slategrey', (112, 128, 144, 1.0)), + ('snow', (255, 250, 250, 1.0)), + ('springgreen', (0, 255, 127, 1.0)), + ('steelblue', (70, 130, 180, 1.0)), + ('tan', (210, 180, 140, 1.0)), + ('teal', (0, 128, 128, 1.0)), + ('thistle', (216, 191, 216, 1.0)), + ('tomato', (255, 99, 71, 1.0)), + ('turquoise', (64, 224, 208, 1.0)), + ('violet', (238, 130, 238, 1.0)), + ('wheat', (245, 222, 179, 1.0)), + ('white', (255, 255, 255, 1.0)), + ('whitesmoke', (245, 245, 245, 1.0)), + ('yellow', (255, 255, 0, 1.0)), + ('yellowgreen', (154, 205, 50, 1.0)), +] + + +def replace(s, i, r): + i %= len(s) + return s[:i] + r(s[i]) + s[i + 1:] + + +def rgba_to_str(r, g, b, a=1.0): + if a == 1.0: + return '"rgb({:g}, {:g}, {:g})"'.format(r, g, b) + else: + return '"rgba({:g}, {:g}, {:g}, {:g})"'.format(r, g, b, a) + + +print('[') +print(',\n'.join( + '"%s", %s' % (css, rgba_to_str(*rgba) if valid else 'null') + for i, (keyword, rgba) in enumerate(all_keywords) + for css, valid, run in [ + (keyword, True, True), + (replace(keyword, i, str.upper), True, True), + (replace(keyword, i, lambda c: r'\\' + c), True, + keyword[i % len(keyword)] not in 'abcdef'), + (replace(keyword, i, lambda c: r'\\%X ' % ord(c)), True, True), + (replace(keyword, i, lambda c: ''), False, True), + # Kelving sign: u'K'.lower() == u'k', but should not match in CSS + (keyword.replace('k', u'K'), False, 'k' in keyword) + ] + if run +)) +print(']')
diff --git a/src/css-parsing-tests/make_color4_color_function.py b/src/css-parsing-tests/make_color4_color_function.py new file mode 100644 index 0000000..28df857 --- /dev/null +++ b/src/css-parsing-tests/make_color4_color_function.py
@@ -0,0 +1,52 @@ +COLOR_SPACES = [ + 'srgb', + 'srgb-linear', + 'display-p3', + 'a98-rgb', + 'prophoto-rgb', + 'rec2020', + 'xyz', + 'xyz-d50', + 'xyz-d65' +] +PERMUTATIONS = [ + ('0% 0% 0%', '0 0 0'), + ('10% 10% 10%', '0.1 0.1 0.1'), + ('.2 .2 25%', '0.2 0.2 0.25'), + ('0 0 0 / 1', '0 0 0'), + ('0% 0 0 / 0.5', '0 0 0 / 0.5'), + ('20% 0 10/0.5', '0.2 0 10 / 0.5'), + ('20% 0 10/50%', '0.2 0 10 / 0.5'), + ('400% 0 10/50%', '4 0 10 / 0.5'), + ('50% -160 160', '0.5 -160 160'), + ('50% -200 200', '0.5 -200 200'), + ('0 0 0 / -10%', '0 0 0 / 0'), + ('0 0 0 / 110%', '0 0 0'), + ('0 0 0 / 300%', '0 0 0'), + ('200 200 200', '200 200 200'), + ('200 200 200 / 200', '200 200 200'), + ('-200 -200 -200', '-200 -200 -200'), + ('-200 -200 -200 / -200', '-200 -200 -200 / 0'), + ('200% 200% 200%', '2 2 2'), + ('200% 200% 200% / 200%', '2 2 2'), + ('-200% -200% -200% / -200%', '-2 -2 -2 / 0'), +] + + +def result_color_space(color_space): + if color_space == 'xyz': + return 'xyz-d65' + else: + return color_space + + +lines = [] +for color_space in COLOR_SPACES: + for permutation in PERMUTATIONS: + lines.append(' "color({} {})", "color({} {})"'.format( + color_space, permutation[0], result_color_space(color_space), permutation[1])) + + +print("[") +print(',\n'.join(lines)) +print("]")
diff --git a/src/css-parsing-tests/make_color4_hwb.py b/src/css-parsing-tests/make_color4_hwb.py new file mode 100644 index 0000000..4aa99f0 --- /dev/null +++ b/src/css-parsing-tests/make_color4_hwb.py
@@ -0,0 +1,59 @@ +import colorsys +from decimal import Decimal + + +def hwb_to_rgb(hue, white, black): + """ + Based on https://github.com/web-platform-tests/wpt/blob/master/css/css-color/color-resolving-hwb.html + """ + if white + black >= 1: + gray = min(max(round(white / (white + black) * 255.0), 0.0), 255.0) + return (gray, gray, gray) + + rgb = colorsys.hls_to_rgb( + hue / 360.0, + 0.5, + 1.0 + ) + + t = (1.0 - white - black) + return tuple([min(max(round((fix_rounding_error(x) * t + white) * 255.0), 0.0), 255.0) for x in rgb]) + + +def fix_rounding_error(x): + # We get rounding errors on these values, so let's just + # brute force fix (haxX0r!1) them! + if x == 76 or x == 127 or x == 178: + return x + 1 + return x + + +def rgba_to_str(r, g, b, a=1.0): + r = fix_rounding_error(r) + g = fix_rounding_error(g) + b = fix_rounding_error(b) + + if a == 1.0: + return 'rgb({:g}, {:g}, {:g})'.format(r, g, b) + else: + return 'rgba({:g}, {:g}, {:g}, {:g})'.format(r, g, b, a) + + +items = [] +for hue in [0, 30, 60, 90, 120, 180, 210, 240, 270, 300, 330, 360]: + for white in [0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]: + for black in [0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0]: + (r, g, b) = hwb_to_rgb(hue, white, black) + items.append('"hwb({:g}deg {:g}% {:g}%)", "{}"'.format( + hue, white * 100, black * 100, rgba_to_str(r, g, b))) + items.append('"hwb({:g} {:g}% {:g}%)", "{}"'.format( + hue, white * 100, black * 100, rgba_to_str(r, g, b))) + for alpha in [0, 0.2, 1]: + items.append('"hwb({:g}deg {:g}% {:g}% / {:g})", "{}"'.format( + hue, white * 100, black * 100, alpha, rgba_to_str(r, g, b, alpha))) + items.append('"hwb({:g} {:g}% {:g}% / {:g})", "{}"'.format( + hue, white * 100, black * 100, alpha, rgba_to_str(r, g, b, alpha))) + +print('[') +print(',\n'.join(items)) +print(']')
diff --git a/src/css-parsing-tests/make_color4_lab_lch_oklab_oklch.py b/src/css-parsing-tests/make_color4_lab_lch_oklab_oklch.py new file mode 100644 index 0000000..69fb8f0 --- /dev/null +++ b/src/css-parsing-tests/make_color4_lab_lch_oklab_oklch.py
@@ -0,0 +1,99 @@ +items = [] + + +def lab(lightness, a, b, alpha=1): + return (lightness, a, b, alpha) + + +def labp(lightness, a, b, alpha=1): + return (lightness, a * 125.0 / 100.0, b * 125.0 / 100.0, alpha) + + +def oklab(lightness, a, b, alpha=1): + return (lightness, a, b, alpha) + + +def oklabp(lightness, a, b, alpha=1): + return (lightness / 100.0, a * 0.4 / 100.0, b * 0.4 / 100.0, alpha) + + +def slab(name, lightness, a, b, alpha=1): + if alpha == 1.0: + return '{}({:g} {:g} {:g})'.format(name, lightness, a, b) + else: + return '{}({:g} {:g} {:g} / {:g})'.format(name, lightness, a, b, alpha) + + +def lab_like(name, f, fp): + for b in [0.0, 10.0, 110.0, -10.0]: + for a in [0.0, 10.0, 110.0, -10.0]: + for lightness in [0.0, 10.0, 110.0, -10.0]: + items.append('"{}({:g} {:g} {:g})", "{:s}"'.format( + name, lightness, a, b, slab(name, *f(lightness, a, b)))) + items.append('"{}({:g}% {:g}% {:g}%)", "{:s}"'.format( + name, lightness, a, b, slab(name, *fp(lightness, a, b)))) + for alpha in [0, 0.2, 1]: + items.append('"{}({:g} {:g} {:g} / {:g})", "{:s}"'.format( + name, lightness, a, b, alpha, slab(name, *f(lightness, a, b, alpha)))) + items.append('"{}({:g}% {:g}% {:g}% / {:g})", "{:s}"'.format( + name, lightness, a, b, alpha, slab(name, *fp(lightness, a, b, alpha)))) + + +lab_like('lab', lab, labp) +lab_like('oklab', oklab, oklabp) + + +def calc_deg(deg): + while deg >= 360.0: + deg -= 360.0 + while deg < 0.0: + deg += 360.0 + + return deg + + +def lch(lightness, c, h, alpha=1): + return (lightness, c, calc_deg(h), alpha) + + +def lchp(lightness, c, h, alpha=1): + return (lightness, c * 150.0 / 100.0, calc_deg(h), alpha) + + +def oklch(lightness, c, h, alpha=1): + return (lightness, c, calc_deg(h), alpha) + + +def oklchp(lightness, c, h, alpha=1): + return (lightness / 100.0, c * 0.4 / 100.0, calc_deg(h), alpha) + + +def slch(name, lightness, c, h, alpha=1): + if alpha == 1: + return '{}({:g} {:g} {:g})'.format(name, lightness, c, h) + else: + return '{}({:g} {:g} {:g} / {:g})'.format(name, lightness, c, h, alpha) + + +def lch_like(name, f, fp): + for h in [0, 30, 60, 90, 120, 180, 210, 240, 270, 300, 330, 360, 380, 700, -20]: + for c in [0.0, 10.0, 110.0, -10.0]: + for lightness in [0.0, 10.0, 110.0, -10.0]: + items.append('"{}({:g} {:g} {:g})", "{:s}"'.format( + name, lightness, c, h, slch(name, *f(lightness, c, h)))) + items.append('"{}({:g}% {:g}% {:g}deg)", "{:s}"'.format( + name, lightness, c, h, slch(name, *fp(lightness, c, h)))) + for alpha in [0, 0.2, 1]: + items.append('"{}({:g} {:g} {:g} / {:g})", "{:s}"'.format( + name, lightness, c, h, alpha, slch(name, *f(lightness, c, h, alpha)))) + items.append('"{}({:g}% {:g}% {:g}deg / {:g})", "{:s}"'.format( + name, lightness, c, h, alpha, slch(name, *fp(lightness, c, h, alpha)))) + + +lch_like('lch', lch, lchp) +lch_like('oklch', oklch, oklchp) + + +print('[') +print(',\n'.join(items)) +print(']')
diff --git a/src/css-parsing-tests/one_component_value.json b/src/css-parsing-tests/one_component_value.json new file mode 100644 index 0000000..c487b57 --- /dev/null +++ b/src/css-parsing-tests/one_component_value.json
@@ -0,0 +1,27 @@ +[ + +"", ["error", "empty"], +" ", ["error", "empty"], +"/**/", ["error", "empty"], +" /**/\t/* a */\n\n", ["error", "empty"], + +".", ".", +"a", ["ident", "a"], +"/**/ 4px", ["dimension", "4", 4, "integer", "px"], +"rgba(100%, 0%, 50%, .5)", ["function", "rgba", + ["percentage", "100", 100, "integer"], ",", " ", + ["percentage", "0", 0, "integer"], ",", " ", + ["percentage", "50", 50, "integer"], ",", " ", + ["number", "0.5", 0.5, "number"] +], + +" /**/ { foo: bar; @baz [)", ["{}", + " ", ["ident", "foo"], ":", " ", ["ident", "bar"], ";", " ", + ["at-keyword", "baz"], " ", ["[]", + ["error", ")"] + ] +], + +".foo", ["error", "extra-input"] + +]
diff --git a/src/css-parsing-tests/one_declaration.json b/src/css-parsing-tests/one_declaration.json new file mode 100644 index 0000000..b7fa610 --- /dev/null +++ b/src/css-parsing-tests/one_declaration.json
@@ -0,0 +1,46 @@ +[ + +"", ["error", "empty"], +" /**/\n", ["error", "empty"], +" ;", ["error", "invalid"], +"foo", ["error", "invalid"], +"@foo:", ["error", "invalid"], +"#foo:", ["error", "invalid"], +".foo:", ["error", "invalid"], +"foo*:", ["error", "invalid"], +"foo.. 9000", ["error", "invalid"], +"foo:", ["declaration", "foo", [], false], +"foo :", ["declaration", "foo", [], false], +"\n/**/ foo: ", ["declaration", "foo", [" "], false], +"foo:;", ["declaration", "foo", [";"], false], +" /**/ foo /**/ :", ["declaration", "foo", [], false], +"foo:;bar:;", ["declaration", "foo", [";", ["ident", "bar"], ":", ";"], false], + +"foo: 9000 !Important", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " " +], true], +"foo: 9000 ! /**/\t IMPORTant /**/\f", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " " +], true], + +"foo: 9000 /* Dotted capital I */!Ä°mportant", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " ", "!", ["ident", "Ä°mportant"] +], false], +"foo: 9000 !important!", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " ", "!", ["ident", "important"], "!" +], false], + +"foo: 9000 important", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " ", ["ident", "important"] +], false], +"foo:important", ["declaration", "foo", [ + ["ident", "important"] +], false], + +"foo: 9000 @bar{ !important", ["declaration", "foo", [ + " ", ["number", "9000", 9000, "integer"], " ", ["at-keyword", "bar"], ["{}", + " ", "!", ["ident", "important"] + ] +], false] + +]
diff --git a/src/css-parsing-tests/one_rule.json b/src/css-parsing-tests/one_rule.json new file mode 100644 index 0000000..677a67a --- /dev/null +++ b/src/css-parsing-tests/one_rule.json
@@ -0,0 +1,40 @@ +[ + +"", ["error", "empty"], +"foo", ["error", "invalid"], +"foo 4", ["error", "invalid"], + +"@foo", ["at-rule", "foo", [], null], + +"@foo bar; \t/* comment */", ["at-rule", "foo", [" ", ["ident", "bar"]], null], +" /**/ @foo-with-block bar{[(4", ["at-rule", "foo-with-block", + [" ", ["ident", "bar"]], + [["[]", ["()", ["number", "4", 4, "integer"]]]] +], + +"@foo-with-block { bar", ["at-rule", "foo-with-block", [" "], [ + " ", ["ident", "bar"]] +], +"@foo [ bar", ["at-rule", "foo", + [" ", ["[]", " ", ["ident", "bar"]]], null +], + +" /**/ div > p { color: #aaa; } /**/ ", ["qualified rule", + [["ident", "div"], " ", ">", " ", ["ident", "p"], " "], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], ";", " "] +], + +" /**/ { color: #aaa ", ["qualified rule", + [], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], " "] +], + +" /* CDO/CDC are not special */ <!-- --> {", ["qualified rule", + ["<!--", " ", "-->", " "], [] +], + +"div { color: #aaa; } p{}", ["error", "extra-input"], +"div {} -->", ["error", "extra-input"], +"{}a", ["error", "extra-input"] + +]
diff --git a/src/css-parsing-tests/rule_list.json b/src/css-parsing-tests/rule_list.json new file mode 100644 index 0000000..7e50364 --- /dev/null +++ b/src/css-parsing-tests/rule_list.json
@@ -0,0 +1,55 @@ +[ + +"", [], +"foo", [["error", "invalid"]], +"foo 4", [["error", "invalid"]], + +"@foo", [["at-rule", "foo", [], null]], + +"@charset; @foo", [ + ["error", "invalid"], + ["at-rule", "foo", [], null] +], + +"@foo bar; \t/* comment */", [["at-rule", "foo", [" ", ["ident", "bar"]], null]], + +" /**/ @foo-with-block bar{[(4", [["at-rule", "foo-with-block", + [" ", ["ident", "bar"]], + [["[]", ["()", ["number", "4", 4, "integer"]]]] +]], + +"@foo-with-block { bar", [["at-rule", "foo-with-block", [" "], [ + " ", ["ident", "bar"]]] +], +"@foo [ bar", [["at-rule", "foo", [" ", ["[]", " ", ["ident", "bar"]]], null]], + +" /**/ div > p { color: #aaa; } /**/ ", [["qualified rule", + [["ident", "div"], " ", ">", " ", ["ident", "p"], " "], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], ";", " "] +]], + +" /**/ { color: #aaa ", [["qualified rule", + [], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], " "] +]], + +" /* CDO/CDC are not special */ <!-- --> {", [["qualified rule", + ["<!--", " ", "-->", " "], [] +]], + +"div { color: #aaa; } p{}", [ + ["qualified rule", [["ident", "div"], " "], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], ";", " "] + ], + ["qualified rule", [["ident", "p"]], []] +], + +"div {} -->", [ + ["qualified rule", [["ident", "div"], " "], []], + ["error", "invalid"] +], + +"{}a", [["qualified rule", [], []], ["error", "invalid"]], +"{}@a", [["qualified rule", [], []], ["at-rule", "a", [], null]] + +]
diff --git a/src/css-parsing-tests/stylesheet.json b/src/css-parsing-tests/stylesheet.json new file mode 100644 index 0000000..5624b27 --- /dev/null +++ b/src/css-parsing-tests/stylesheet.json
@@ -0,0 +1,53 @@ +[ + +"", [], +"foo", [["error", "invalid"]], +"foo 4", [["error", "invalid"]], + +"@foo", [["at-rule", "foo", [], null]], + +"@charset 4 {} @foo", [["at-rule", "foo", [], null]], + +"@foo; @charset 4 {}", [ + ["at-rule", "foo", [], null], + ["error", "invalid"] +], + +"@foo bar; \t/* comment */", [["at-rule", "foo", [" ", ["ident", "bar"]], null]], + +" /**/ @foo-with-block bar{[(4", [["at-rule", "foo-with-block", + [" ", ["ident", "bar"]], + [["[]", ["()", ["number", "4", 4, "integer"]]]] +]], + +"@foo-with-block { bar", [["at-rule", "foo-with-block", [" "], [ + " ", ["ident", "bar"]]] +], +"@foo [ bar", [["at-rule", "foo", [" ", ["[]", " ", ["ident", "bar"]]], null]], + +" /**/ div > p { color: #aaa; } /**/ ", [["qualified rule", + [["ident", "div"], " ", ">", " ", ["ident", "p"], " "], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], ";", " "] +]], + +" /**/ { color: #aaa ", [["qualified rule", + [], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], " "] +]], + +" /* CDO/CDC are ignored between rules */ <!-- --> {", [["qualified rule", [], []]], +" <!-- --> a<!---->{", [["qualified rule", [["ident", "a"], "<!--", "-->"], []]], + +"div { color: #aaa; } p{}", [ + ["qualified rule", [["ident", "div"], " "], + [" ", ["ident", "color"], ":", " ", ["hash", "aaa", "id"], ";", " "] + ], + ["qualified rule", [["ident", "p"]], []] +], + +"div {} -->", [["qualified rule", [["ident", "div"], " "], []]], + +"{}a", [["qualified rule", [], []], ["error", "invalid"]], +"{}@a", [["qualified rule", [], []], ["at-rule", "a", [], null]] + +]
diff --git a/src/css-parsing-tests/stylesheet_bytes.json b/src/css-parsing-tests/stylesheet_bytes.json new file mode 100644 index 0000000..e990048 --- /dev/null +++ b/src/css-parsing-tests/stylesheet_bytes.json
@@ -0,0 +1,134 @@ +[ + +{"css_bytes": ""}, +[[], "utf-8"], + +{"css_bytes": "@\u00C3\u00A9", + "protocol_encoding": null, "environment_encoding": null}, +[[["at-rule", "é", [], null]], "utf-8"], + +{"css_bytes": "@\u00C3\u00A9"}, +[[["at-rule", "é", [], null]], "utf-8"], + +{"css_bytes": "@\u0000\u00E9\u0000", + "comment": "Untagged UTF-16, parsed as UTF-8"}, +[[["at-rule", "���", [], null]], "utf-8"], + +{"css_bytes": "\u00FF\u00FE@\u0000\u00E9\u0000", + "comment": "UTF-16 with a BOM"}, +[[["at-rule", "é", [], null]], "utf-16le"], + +{"css_bytes": "\u00FE\u00FF\u0000@\u0000\u00E9"}, +[[["at-rule", "é", [], null]], "utf-16be"], + +{"css_bytes": "@\u00E9"}, +[[["at-rule", "�", [], null]], "utf-8"], + + +{"css_bytes": "@\u00E9", "protocol_encoding": "ISO-8859-2"}, +[[["at-rule", "é", [], null]], "iso-8859-2"], + +{"css_bytes": "@\u00E9", "protocol_encoding": "ISO-8859-5"}, +[[["at-rule", "щ", [], null]], "iso-8859-5"], + +{"css_bytes": "@\u00C3\u00A9", "protocol_encoding": "ISO-8859-2"}, +[[["at-rule", "Ä‚Š", [], null]], "iso-8859-2"], + +{"css_bytes": "\u00EF\u00BB\u00BF @\u00C3\u00A9", + "protocol_encoding": "ISO-8859-2", + "comment": "BOM takes precedence over protocol"}, +[[["at-rule", "é", [], null]], "utf-8"], + + +{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9"}, +[[["at-rule", "щ", [], null]], + "iso-8859-5"], + +{"css_bytes": "@Charset \"ISO-8859-5\"; @\u00E9", + "comment": "@charset has to match an exact byte pattern"}, +[[["at-rule", "�", [], null]], + "utf-8"], + +{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9", + "comment": "@charset has to match an exact byte pattern"}, +[[["at-rule", "�", [], null]], + "utf-8"], + +{"css_bytes": "@charset 'ISO-8859-5'; @\u00E9", + "comment": "@charset has to match an exact byte pattern"}, +[[["at-rule", "�", [], null]], + "utf-8"], + +{"css_bytes": "@charset \"ISO-8859-5\" ; @\u00E9", + "comment": "@charset has to match an exact byte pattern"}, +[[["at-rule", "�", [], null]], + "utf-8"], + + +{"css_bytes": "@\u0000c\u0000h\u0000a\u0000r\u0000s\u0000e\u0000t\u0000 \u0000\"\u0000U\u0000T\u0000F\u0000-\u00001\u00006\u0000L\u0000E\u0000\"\u0000;\u0000@\u0000\u00e9\u0000", + "comment": "@charset has to be ASCII-compatible itself"}, +[[["at-rule", "�c�h�a�r�s�e�t�", + [" ", ["ident", "�"], ["string", "�U�T�F�-�1�6�L�E�"], ["ident", "�"]], null], + ["error", "invalid"]], + "utf-8"], + +{"css_bytes": "@charset \"UTF-16LE\"; @\u00C3\u00A9", + "comment": "@charset can only specify ASCII-compatible encodings"}, +[[["at-rule", "é", [], null]], + "utf-8"], + + +{"css_bytes": "\u00EF\u00BB\u00BF @charset \"ISO-8859-5\"; @\u00E9", + "comment": "BOM takes precedence over @charset"}, +[[["at-rule", "�", [], null]], + "utf-8"], + +{"css_bytes": "\u00EF\u00BB\u00BF @charset \"ISO-8859-5\"; @\u00C3\u00A9", + "comment": "BOM takes precedence over @charset"}, +[[["at-rule", "é", [], null]], + "utf-8"], + +{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9", + "protocol_encoding": " Iso-8859-2", + "comment": "Protocol takes precedence over @charset"}, +[[["at-rule", "é", [], null]], + "iso-8859-2"], + +{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9", + "protocol_encoding": "kamoulox", + "comment": "Unknown protocol encoding falls back to @charset"}, +[[["at-rule", "щ", [], null]], + "iso-8859-5"], + + +{"css_bytes": "@\u00E9", "environment_encoding": "ISO-8859-2"}, +[[["at-rule", "é", [], null]], "iso-8859-2"], + +{"css_bytes": "@\u00E9", "environment_encoding": "ISO-8859-5"}, +[[["at-rule", "щ", [], null]], "iso-8859-5"], + +{"css_bytes": "@charset \"ISO-8859-5\"; @\u00E9", + "environment_encoding": "ISO-8859-2", + "comment": "@character takes precedence over environment"}, +[[["at-rule", "щ", [], null]], + "iso-8859-5"], + +{"css_bytes": "@charset \"kamoulox\"; @\u00E9", + "environment_encoding": "ISO-8859-2", + "comment": "@character with unknown encoding falls back to environment encoding"}, +[[["at-rule", "é", [], null]], + "iso-8859-2"], + +{"css_bytes": "@\u00E9", + "protocol_encoding": "ISO-8859-2", + "environment_encoding": "ISO-8859-5", + "comment": "protocol takes precedence over environment"}, +[[["at-rule", "é", [], null]], "iso-8859-2"], + +{"css_bytes": "\u00EF\u00BB\u00BF @\u00C3\u00A9", + "environment_encoding": "ISO-8859-5", + "comment": "BOM takes precedence over environment"}, +[[["at-rule", "é", [], null]], "utf-8"] + + +]
diff --git a/src/css-parsing-tests/urange.json b/src/css-parsing-tests/urange.json new file mode 100644 index 0000000..4dcb529 --- /dev/null +++ b/src/css-parsing-tests/urange.json
@@ -0,0 +1,94 @@ +[ + +"u+1, U+10, U+100, U+1000, U+10000, U+100000, U+1000000", [ + [1, 1], + [16, 16], + [256, 256], + [4096, 4096], + [65536, 65536], + [1048576, 1048576], + null +], + +"u+?, u+1?, U+10?, U+100?, U+1000?, U+10000?, U+100000?", [ + [0, 15], + [16, 31], + [256, 271], + [4096, 4111], + [65536, 65551], + [1048576, 1048591], + null +], + +"u+??, U+1??, U+10??, U+100??, U+1000??, U+10000??", [ + [0, 255], + [256, 511], + [4096, 4351], + [65536, 65791], + [1048576, 1048831], + null +], + +"u+???, U+1???, U+10???, U+100???, U+1000???", [ + [0, 4095], + [4096, 8191], + [65536, 69631], + [1048576, 1052671], + null +], + +"u+????, U+1????, U+10????, U+100????", [ + [0, 65535], + [65536, 131071], + [1048576, 1114111], + null +], + +"u+?????, U+1?????, U+10?????", [ + [0, 1048575], + null, + null +], + +"u+??????, U+1??????", [ + null, + null +], + +"U+2 , U+???", [ + [2, 2], + [0, 4095] +], + +"U+4E-9F", [ + [78, 159] +], + +"u+20-3F, u+3F-3F, u+3F-3E, U+0-110000, U+0-10FFFF, U+100000-2, U+1000000-2, U+10-200000", [ + [32, 63], + [63, 63], + null, + null, + [0, 1114111], + null, + null, + null +], + +"ù+12, Ü+12, u +12, U+ 12, U+12 - 20, U+1?2, U+1?-50, U+1- 2", [ + null, + null, + null, + null, + null, + null, + null, + null +], + +"U+26F9200D2640, U+10000-26F9200D2640", [ + null, + null +] + +]
diff --git a/src/from_bytes.rs b/src/from_bytes.rs new file mode 100644 index 0000000..7d9d2c7 --- /dev/null +++ b/src/from_bytes.rs
@@ -0,0 +1,64 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/// Abstraction for avoiding a dependency from cssparser to an encoding library +pub trait EncodingSupport { + /// One character encoding + type Encoding; + + /// https://encoding.spec.whatwg.org/#concept-encoding-get + fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding>; + + /// Return the UTF-8 encoding + fn utf8() -> Self::Encoding; + + /// Whether the given encoding is UTF-16BE or UTF-16LE + fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool; +} + +/// Determine the character encoding of a CSS stylesheet. +/// +/// This is based on the presence of a BOM (Byte Order Mark), an `@charset` rule, and +/// encoding meta-information. +/// +/// * `css_bytes`: A byte string. +/// * `protocol_encoding`: The encoding label, if any, defined by HTTP or equivalent protocol. +/// (e.g. via the `charset` parameter of the `Content-Type` header.) +/// * `environment_encoding`: An optional `Encoding` object for the [environment encoding] +/// (https://drafts.csswg.org/css-syntax/#environment-encoding), if any. +/// +/// Returns the encoding to use. +pub fn stylesheet_encoding<E>( + css: &[u8], + protocol_encoding_label: Option<&[u8]>, + environment_encoding: Option<E::Encoding>, +) -> E::Encoding +where + E: EncodingSupport, +{ + // https://drafts.csswg.org/css-syntax/#the-input-byte-stream + if let Some(label) = protocol_encoding_label { + if let Some(protocol_encoding) = E::from_label(label) { + return protocol_encoding; + }; + }; + + let prefix = b"@charset \""; + if css.starts_with(prefix) { + let rest = &css[prefix.len()..]; + if let Some(label_length) = rest.iter().position(|&b| b == b'"') { + if rest[label_length..].starts_with(b"\";") { + let label = &rest[..label_length]; + if let Some(charset_encoding) = E::from_label(label) { + if E::is_utf16_be_or_le(&charset_encoding) { + return E::utf8(); + } else { + return charset_encoding; + } + } + } + } + } + environment_encoding.unwrap_or_else(E::utf8) +}
diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..dc44fb7 --- /dev/null +++ b/src/lib.rs
@@ -0,0 +1,108 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#![crate_name = "cssparser"] +#![crate_type = "rlib"] +#![cfg_attr(feature = "bench", feature(test))] +#![deny(missing_docs)] + +/*! + +Implementation of [CSS Syntax Module Level 3](https://drafts.csswg.org/css-syntax/) for Rust. + +# Input + +Everything is based on `Parser` objects, which borrow a `&str` input. +If you have bytes (from a file, the network, or something) +and want to support character encodings other than UTF-8, +see the `stylesheet_encoding` function, +which can be used together with rust-encoding or encoding-rs. + +# Conventions for parsing functions + +* Take (at least) a `input: &mut cssparser::Parser` parameter +* Return `Result<_, ()>` +* When returning `Ok(_)`, + the function must have consumed exactly the amount of input that represents the parsed value. +* When returning `Err(())`, any amount of input may have been consumed. + +As a consequence, when calling another parsing function, either: + +* Any `Err(())` return value must be propagated. + This happens by definition for tail calls, + and can otherwise be done with the `?` operator. +* Or the call must be wrapped in a `Parser::try` call. + `try` takes a closure that takes a `Parser` and returns a `Result`, + calls it once, + and returns itself that same result. + If the result is `Err`, + it restores the position inside the input to the one saved before calling the closure. + +Examples: + +```{rust,ignore} +// 'none' | <image> +fn parse_background_image(context: &ParserContext, input: &mut Parser) + -> Result<Option<Image>, ()> { + if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() { + Ok(None) + } else { + Image::parse(context, input).map(Some) // tail call + } +} +``` + +```{rust,ignore} +// [ <length> | <percentage> ] [ <length> | <percentage> ]? +fn parse_border_spacing(_context: &ParserContext, input: &mut Parser) + -> Result<(LengthOrPercentage, LengthOrPercentage), ()> { + let first = LengthOrPercentage::parse?; + let second = input.try_parse(LengthOrPercentage::parse).unwrap_or(first); + (first, second) +} +``` + +*/ + +#![recursion_limit = "200"] // For color::parse_color_keyword + +pub use crate::cow_rc_str::CowRcStr; +pub use crate::from_bytes::{stylesheet_encoding, EncodingSupport}; +#[doc(hidden)] +pub use crate::macros::{ + _cssparser_internal_create_uninit_array, _cssparser_internal_to_lowercase, +}; +pub use crate::nth::parse_nth; +pub use crate::parser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind}; +pub use crate::parser::{Delimiter, Delimiters, Parser, ParserInput, ParserState}; +pub use crate::rules_and_declarations::{parse_important, parse_one_declaration}; +pub use crate::rules_and_declarations::{parse_one_rule, StyleSheetParser}; +pub use crate::rules_and_declarations::{AtRuleParser, QualifiedRuleParser}; +pub use crate::rules_and_declarations::{DeclarationParser, RuleBodyItemParser, RuleBodyParser}; +pub use crate::serializer::{serialize_identifier, serialize_name, serialize_string}; +pub use crate::serializer::{CssStringWriter, ToCss, TokenSerializationType}; +pub use crate::tokenizer::{SourceLocation, SourcePosition, Token}; +pub use crate::unicode_range::UnicodeRange; +pub use cssparser_macros::*; +#[doc(hidden)] +pub use phf as _cssparser_internal_phf; + +#[macro_use] +mod macros; + +mod rules_and_declarations; +mod tokenizer; + +pub mod color; +mod cow_rc_str; +mod from_bytes; +mod nth; +mod parser; +mod serializer; +mod unicode_range; + +#[cfg(test)] +mod size_of_tests; +#[cfg(test)] +mod tests;
diff --git a/src/macros.rs b/src/macros.rs new file mode 100644 index 0000000..67d8365 --- /dev/null +++ b/src/macros.rs
@@ -0,0 +1,204 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use std::mem::MaybeUninit; + +/// Expands to a `match` expression with string patterns, +/// matching case-insensitively in the ASCII range. +/// +/// The patterns must not contain ASCII upper case letters. (They must be already be lower-cased.) +/// +/// # Example +/// +/// ```rust +/// # fn main() {} // Make doctest not wrap everything in its own main +/// # fn dummy(function_name: &String) { let _ = +/// cssparser::match_ignore_ascii_case! { &function_name, +/// "rgb" => parse_rgb(..), +/// # #[cfg(not(something))] +/// "rgba" => parse_rgba(..), +/// "hsl" => parse_hsl(..), +/// "hsla" => parse_hsla(..), +/// _ => Err(format!("unknown function: {}", function_name)) +/// } +/// # ;} +/// # use std::ops::RangeFull; +/// # fn parse_rgb(_: RangeFull) -> Result<(), String> { Ok(()) } +/// # fn parse_rgba(_: RangeFull) -> Result<(), String> { Ok(()) } +/// # fn parse_hsl(_: RangeFull) -> Result<(), String> { Ok(()) } +/// # fn parse_hsla(_: RangeFull) -> Result<(), String> { Ok(()) } +/// ``` +#[macro_export] +macro_rules! match_ignore_ascii_case { + ( $input:expr, + $( + $( #[$meta: meta] )* + $( $pattern: pat )|+ $( if $guard: expr )? => $then: expr + ),+ + $(,)? + ) => { + { + // This dummy module works around the feature gate + // `error[E0658]: procedural macros cannot be expanded to statements` + // by forcing the macro to be in an item context + // rather than expression/statement context, + // even though the macro only expands to items. + mod cssparser_internal { + $crate::_cssparser_internal_max_len! { + $( $( $pattern )+ )+ + } + } + $crate::_cssparser_internal_to_lowercase!($input, cssparser_internal::MAX_LENGTH => lowercase); + // "A" is a short string that we know is different for every string pattern, + // since we’ve verified that none of them include ASCII upper case letters. + match lowercase.unwrap_or("A") { + $( + $( #[$meta] )* + $( $pattern )|+ $( if $guard )? => $then, + )+ + } + } + }; +} + +/// Define a function `$name(&str) -> Option<&'static $ValueType>` +/// +/// The function finds a match for the input string +/// in a [`phf` map](https://github.com/sfackler/rust-phf) +/// and returns a reference to the corresponding value. +/// Matching is case-insensitive in the ASCII range. +/// +/// ## Example: +/// +/// ```rust +/// # fn main() {} // Make doctest not wrap everything in its own main +/// +/// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> { +/// cssparser::ascii_case_insensitive_phf_map! { +/// keywords -> (u8, u8, u8) = { +/// "red" => (255, 0, 0), +/// "green" => (0, 255, 0), +/// "blue" => (0, 0, 255), +/// } +/// } +/// keywords::get(input).cloned() +/// } +/// ``` +/// +/// You can also iterate over the map entries by using `keywords::entries()`. +#[macro_export] +macro_rules! ascii_case_insensitive_phf_map { + ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => { + ascii_case_insensitive_phf_map!($name -> $ValueType = { $( $key => $value, )+ }) + }; + ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => { + use $crate::_cssparser_internal_phf as phf; + + // See macro above for context. + mod cssparser_internal { + $crate::_cssparser_internal_max_len! { + $( $key )+ + } + } + + static MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! { + $( + $key => $value, + )* + }; + + // While the obvious choice for this would be an inner module, it's not possible to + // reference from types from there, see: + // <https://github.com/rust-lang/rust/issues/114369> + // + // So we abuse a struct with static associated functions instead. + #[allow(non_camel_case_types)] + struct $name; + impl $name { + #[allow(dead_code)] + fn entries() -> impl Iterator<Item = (&'static &'static str, &'static $ValueType)> { + MAP.entries() + } + + fn get(input: &str) -> Option<&'static $ValueType> { + $crate::_cssparser_internal_to_lowercase!(input, cssparser_internal::MAX_LENGTH => lowercase); + MAP.get(lowercase?) + } + } + } +} + +/// Create a new array of MaybeUninit<T> items, in an uninitialized state. +#[inline(always)] +pub fn _cssparser_internal_create_uninit_array<const N: usize>() -> [MaybeUninit<u8>; N] { + unsafe { + // SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid. + // See: https://doc.rust-lang.org/stable/core/mem/union.MaybeUninit.html#method.uninit_array + MaybeUninit::<[MaybeUninit<u8>; N]>::uninit().assume_init() + } +} + +/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros. +/// +/// **This macro is not part of the public API. It can change or be removed between any versions.** +/// +/// Define a local variable named `$output` +/// and assign it the result of calling `_cssparser_internal_to_lowercase` +/// with a stack-allocated buffer of length `$BUFFER_SIZE`. +#[macro_export] +#[doc(hidden)] +macro_rules! _cssparser_internal_to_lowercase { + ($input: expr, $BUFFER_SIZE: expr => $output: ident) => { + let mut buffer = $crate::_cssparser_internal_create_uninit_array::<{ $BUFFER_SIZE }>(); + let input: &str = $input; + let $output = $crate::_cssparser_internal_to_lowercase(&mut buffer, input); + }; +} + +/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros. +/// +/// **This function is not part of the public API. It can change or be removed between any versions.** +/// +/// If `input` is larger than buffer, return `None`. +/// Otherwise, return `input` ASCII-lowercased, using `buffer` as temporary space if necessary. +#[doc(hidden)] +#[allow(non_snake_case)] +#[inline] +pub fn _cssparser_internal_to_lowercase<'a>( + buffer: &'a mut [MaybeUninit<u8>], + input: &'a str, +) -> Option<&'a str> { + let buffer = buffer.get_mut(..input.len())?; + + #[cold] + fn make_ascii_lowercase<'a>( + buffer: &'a mut [MaybeUninit<u8>], + input: &'a str, + first_uppercase: usize, + ) -> &'a str { + // This cast doesn't change the pointer's validity + // since `u8` has the same layout as `MaybeUninit<u8>`: + let input_bytes = + unsafe { &*(input.as_bytes() as *const [u8] as *const [MaybeUninit<u8>]) }; + + buffer.copy_from_slice(input_bytes); + + // Same as above re layout, plus these bytes have been initialized: + let buffer = unsafe { &mut *(buffer as *mut [MaybeUninit<u8>] as *mut [u8]) }; + + buffer[first_uppercase..].make_ascii_lowercase(); + // `buffer` was initialized to a copy of `input` + // (which is `&str` so well-formed UTF-8) + // then ASCII-lowercased (which preserves UTF-8 well-formedness): + unsafe { ::std::str::from_utf8_unchecked(buffer) } + } + + Some( + match input.bytes().position(|byte| byte.is_ascii_uppercase()) { + Some(first_uppercase) => make_ascii_lowercase(buffer, input, first_uppercase), + // common case: input is already lower-case + None => input, + }, + ) +}
diff --git a/src/nth.rs b/src/nth.rs new file mode 100644 index 0000000..4fe5a6b --- /dev/null +++ b/src/nth.rs
@@ -0,0 +1,145 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use super::{BasicParseError, Parser, ParserInput, Token}; + +/// Parse the *An+B* notation, as found in the `:nth-child()` selector. +/// The input is typically the arguments of a function, +/// in which case the caller needs to check if the arguments’ parser is exhausted. +/// Return `Ok((A, B))`, or an `Err(..)` for a syntax error. +pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicParseError<'i>> { + match *input.next()? { + Token::Number { + int_value: Some(b), .. + } => Ok((0, b)), + Token::Dimension { + int_value: Some(a), + ref unit, + .. + } => { + match_ignore_ascii_case! { + unit, + "n" => Ok(parse_b(input, a)?), + "n-" => Ok(parse_signless_b(input, a, -1)?), + _ => match parse_n_dash_digits(unit) { + Ok(b) => Ok((a, b)), + Err(()) => { + let unit = unit.clone(); + Err(input.new_basic_unexpected_token_error(Token::Ident(unit))) + } + } + } + } + Token::Ident(ref value) => { + match_ignore_ascii_case! { value, + "even" => Ok((2, 0)), + "odd" => Ok((2, 1)), + "n" => Ok(parse_b(input, 1)?), + "-n" => Ok(parse_b(input, -1)?), + "n-" => Ok(parse_signless_b(input, 1, -1)?), + "-n-" => Ok(parse_signless_b(input, -1, -1)?), + _ => { + let (slice, a) = if let Some(stripped) = value.strip_prefix('-') { + (stripped, -1) + } else { + (&**value, 1) + }; + match parse_n_dash_digits(slice) { + Ok(b) => Ok((a, b)), + Err(()) => { + let value = value.clone(); + Err(input.new_basic_unexpected_token_error(Token::Ident(value))) + } + } + } + } + } + Token::Delim('+') => match *input.next_including_whitespace()? { + Token::Ident(ref value) => { + match_ignore_ascii_case! { value, + "n" => parse_b(input, 1), + "n-" => parse_signless_b(input, 1, -1), + _ => match parse_n_dash_digits(value) { + Ok(b) => Ok((1, b)), + Err(()) => { + let value = value.clone(); + Err(input.new_basic_unexpected_token_error(Token::Ident(value))) + } + } + } + } + ref token => { + let token = token.clone(); + Err(input.new_basic_unexpected_token_error(token)) + } + }, + ref token => { + let token = token.clone(); + Err(input.new_basic_unexpected_token_error(token)) + } + } +} + +fn parse_b<'i>(input: &mut Parser<'i, '_>, a: i32) -> Result<(i32, i32), BasicParseError<'i>> { + let start = input.state(); + match input.next() { + Ok(&Token::Delim('+')) => parse_signless_b(input, a, 1), + Ok(&Token::Delim('-')) => parse_signless_b(input, a, -1), + Ok(&Token::Number { + has_sign: true, + int_value: Some(b), + .. + }) => Ok((a, b)), + _ => { + input.reset(&start); + Ok((a, 0)) + } + } +} + +fn parse_signless_b<'i>( + input: &mut Parser<'i, '_>, + a: i32, + b_sign: i32, +) -> Result<(i32, i32), BasicParseError<'i>> { + // FIXME: remove .clone() when lifetimes are non-lexical. + match input.next()?.clone() { + Token::Number { + has_sign: false, + int_value: Some(b), + .. + } => Ok((a, b_sign * b)), + token => Err(input.new_basic_unexpected_token_error(token)), + } +} + +fn parse_n_dash_digits(string: &str) -> Result<i32, ()> { + let bytes = string.as_bytes(); + if bytes.len() >= 3 + && bytes[..2].eq_ignore_ascii_case(b"n-") + && bytes[2..].iter().all(|&c| c.is_ascii_digit()) + { + Ok(parse_number_saturate(&string[1..]).unwrap()) // Include the minus sign + } else { + Err(()) + } +} + +fn parse_number_saturate(string: &str) -> Result<i32, ()> { + let mut input = ParserInput::new(string); + let mut parser = Parser::new(&mut input); + let int = if let Ok(&Token::Number { + int_value: Some(int), + .. + }) = parser.next_including_whitespace_and_comments() + { + int + } else { + return Err(()); + }; + if !parser.is_exhausted() { + return Err(()); + } + Ok(int) +}
diff --git a/src/parser.rs b/src/parser.rs new file mode 100644 index 0000000..aabeea6 --- /dev/null +++ b/src/parser.rs
@@ -0,0 +1,1173 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::cow_rc_str::CowRcStr; +use crate::tokenizer::{SourceLocation, SourcePosition, Token, Tokenizer}; +use smallvec::SmallVec; +use std::fmt; +use std::ops::BitOr; +use std::ops::Range; + +/// A capture of the internal state of a `Parser` (including the position within the input), +/// obtained from the `Parser::position` method. +/// +/// Can be used with the `Parser::reset` method to restore that state. +/// Should only be used with the `Parser` instance it came from. +#[derive(Debug, Clone)] +pub struct ParserState { + pub(crate) position: usize, + pub(crate) current_line_start_position: usize, + pub(crate) current_line_number: u32, + pub(crate) at_start_of: Option<BlockType>, +} + +impl ParserState { + /// The position from the start of the input, counted in UTF-8 bytes. + #[inline] + pub fn position(&self) -> SourcePosition { + SourcePosition(self.position) + } + + /// The line number and column number + #[inline] + pub fn source_location(&self) -> SourceLocation { + SourceLocation { + line: self.current_line_number, + column: (self.position - self.current_line_start_position + 1) as u32, + } + } +} + +/// When parsing until a given token, sometimes the caller knows that parsing is going to restart +/// at some earlier point, and consuming until we find a top level delimiter is just wasted work. +/// +/// In that case, callers can pass ParseUntilErrorBehavior::Stop to avoid doing all that wasted +/// work. +/// +/// This is important for things like CSS nesting, where something like: +/// +/// foo:is(..) { +/// ... +/// } +/// +/// Would need to scan the whole {} block to find a semicolon, only for parsing getting restarted +/// as a qualified rule later. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ParseUntilErrorBehavior { + /// Consume until we see the relevant delimiter or the end of the stream. + Consume, + /// Eagerly error. + Stop, +} + +/// Details about a `BasicParseError` +#[derive(Clone, Debug, PartialEq)] +pub enum BasicParseErrorKind<'i> { + /// An unexpected token was encountered. + UnexpectedToken(Token<'i>), + /// The end of the input was encountered unexpectedly. + EndOfInput, + /// An `@` rule was encountered that was invalid. + AtRuleInvalid(CowRcStr<'i>), + /// The body of an '@' rule was invalid. + AtRuleBodyInvalid, + /// A qualified rule was encountered that was invalid. + QualifiedRuleInvalid, +} + +impl fmt::Display for BasicParseErrorKind<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + BasicParseErrorKind::UnexpectedToken(token) => { + write!(f, "unexpected token: {:?}", token) + } + BasicParseErrorKind::EndOfInput => write!(f, "unexpected end of input"), + BasicParseErrorKind::AtRuleInvalid(rule) => { + write!(f, "invalid @ rule encountered: '@{}'", rule) + } + BasicParseErrorKind::AtRuleBodyInvalid => write!(f, "invalid @ rule body encountered"), + BasicParseErrorKind::QualifiedRuleInvalid => { + write!(f, "invalid qualified rule encountered") + } + } + } +} + +/// The fundamental parsing errors that can be triggered by built-in parsing routines. +#[derive(Clone, Debug, PartialEq)] +pub struct BasicParseError<'i> { + /// Details of this error + pub kind: BasicParseErrorKind<'i>, + /// Location where this error occurred + pub location: SourceLocation, +} + +impl<'i, T> From<BasicParseError<'i>> for ParseError<'i, T> { + #[inline] + fn from(this: BasicParseError<'i>) -> ParseError<'i, T> { + ParseError { + kind: ParseErrorKind::Basic(this.kind), + location: this.location, + } + } +} + +impl SourceLocation { + /// Create a new BasicParseError at this location for an unexpected token + #[inline] + pub fn new_basic_unexpected_token_error(self, token: Token<'_>) -> BasicParseError<'_> { + self.new_basic_error(BasicParseErrorKind::UnexpectedToken(token)) + } + + /// Create a new BasicParseError at this location + #[inline] + pub fn new_basic_error(self, kind: BasicParseErrorKind<'_>) -> BasicParseError<'_> { + BasicParseError { + kind, + location: self, + } + } + + /// Create a new ParseError at this location for an unexpected token + #[inline] + pub fn new_unexpected_token_error<E>(self, token: Token<'_>) -> ParseError<'_, E> { + self.new_error(BasicParseErrorKind::UnexpectedToken(token)) + } + + /// Create a new basic ParseError at the current location + #[inline] + pub fn new_error<E>(self, kind: BasicParseErrorKind<'_>) -> ParseError<'_, E> { + ParseError { + kind: ParseErrorKind::Basic(kind), + location: self, + } + } + + /// Create a new custom ParseError at this location + #[inline] + pub fn new_custom_error<'i, E1: Into<E2>, E2>(self, error: E1) -> ParseError<'i, E2> { + ParseError { + kind: ParseErrorKind::Custom(error.into()), + location: self, + } + } +} + +/// Details of a `ParseError` +#[derive(Clone, Debug, PartialEq)] +pub enum ParseErrorKind<'i, T: 'i> { + /// A fundamental parse error from a built-in parsing routine. + Basic(BasicParseErrorKind<'i>), + /// A parse error reported by downstream consumer code. + Custom(T), +} + +impl<'i, T> ParseErrorKind<'i, T> { + /// Like `std::convert::Into::into` + pub fn into<U>(self) -> ParseErrorKind<'i, U> + where + T: Into<U>, + { + match self { + ParseErrorKind::Basic(basic) => ParseErrorKind::Basic(basic), + ParseErrorKind::Custom(custom) => ParseErrorKind::Custom(custom.into()), + } + } +} + +impl<E: fmt::Display> fmt::Display for ParseErrorKind<'_, E> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + ParseErrorKind::Basic(ref basic) => basic.fmt(f), + ParseErrorKind::Custom(ref custom) => custom.fmt(f), + } + } +} + +/// Extensible parse errors that can be encountered by client parsing implementations. +#[derive(Clone, Debug, PartialEq)] +pub struct ParseError<'i, E> { + /// Details of this error + pub kind: ParseErrorKind<'i, E>, + /// Location where this error occurred + pub location: SourceLocation, +} + +impl<'i, T> ParseError<'i, T> { + /// Extract the fundamental parse error from an extensible error. + pub fn basic(self) -> BasicParseError<'i> { + match self.kind { + ParseErrorKind::Basic(kind) => BasicParseError { + kind, + location: self.location, + }, + ParseErrorKind::Custom(_) => panic!("Not a basic parse error"), + } + } + + /// Like `std::convert::Into::into` + pub fn into<U>(self) -> ParseError<'i, U> + where + T: Into<U>, + { + ParseError { + kind: self.kind.into(), + location: self.location, + } + } +} + +impl<E: fmt::Display> fmt::Display for ParseError<'_, E> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.kind.fmt(f) + } +} + +impl<E: fmt::Display + fmt::Debug> std::error::Error for ParseError<'_, E> {} + +/// The owned input for a parser. +pub struct ParserInput<'i> { + tokenizer: Tokenizer<'i>, + cached_token: Option<CachedToken<'i>>, +} + +struct CachedToken<'i> { + token: Token<'i>, + start_position: SourcePosition, + end_state: ParserState, +} + +impl<'i> ParserInput<'i> { + /// Create a new input for a parser. + pub fn new(input: &'i str) -> ParserInput<'i> { + ParserInput { + tokenizer: Tokenizer::new(input), + cached_token: None, + } + } + + #[inline] + fn cached_token_ref(&self) -> &Token<'i> { + &self.cached_token.as_ref().unwrap().token + } +} + +/// A CSS parser that borrows its `&str` input, +/// yields `Token`s, +/// and keeps track of nested blocks and functions. +pub struct Parser<'i, 't> { + input: &'t mut ParserInput<'i>, + /// If `Some(_)`, .parse_nested_block() can be called. + at_start_of: Option<BlockType>, + /// For parsers from `parse_until` or `parse_nested_block` + stop_before: Delimiters, +} + +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +pub(crate) enum BlockType { + Parenthesis, + SquareBracket, + CurlyBracket, +} + +impl BlockType { + fn opening(token: &Token) -> Option<BlockType> { + match *token { + Token::Function(_) | Token::ParenthesisBlock => Some(BlockType::Parenthesis), + Token::SquareBracketBlock => Some(BlockType::SquareBracket), + Token::CurlyBracketBlock => Some(BlockType::CurlyBracket), + _ => None, + } + } + + fn closing(token: &Token) -> Option<BlockType> { + match *token { + Token::CloseParenthesis => Some(BlockType::Parenthesis), + Token::CloseSquareBracket => Some(BlockType::SquareBracket), + Token::CloseCurlyBracket => Some(BlockType::CurlyBracket), + _ => None, + } + } +} + +/// A set of characters, to be used with the `Parser::parse_until*` methods. +/// +/// The union of two sets can be obtained with the `|` operator. Example: +/// +/// ```{rust,ignore} +/// input.parse_until_before(Delimiter::CurlyBracketBlock | Delimiter::Semicolon) +/// ``` +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +pub struct Delimiters { + bits: u8, +} + +/// `Delimiters` constants. +#[allow(non_upper_case_globals, non_snake_case)] +pub mod Delimiter { + use super::Delimiters; + + /// The empty delimiter set + pub const None: Delimiters = Delimiters { bits: 0 }; + /// The delimiter set with only the `{` opening curly bracket + pub const CurlyBracketBlock: Delimiters = Delimiters { bits: 1 << 1 }; + /// The delimiter set with only the `;` semicolon + pub const Semicolon: Delimiters = Delimiters { bits: 1 << 2 }; + /// The delimiter set with only the `!` exclamation point + pub const Bang: Delimiters = Delimiters { bits: 1 << 3 }; + /// The delimiter set with only the `,` comma + pub const Comma: Delimiters = Delimiters { bits: 1 << 4 }; +} + +#[allow(non_upper_case_globals, non_snake_case)] +mod ClosingDelimiter { + use super::Delimiters; + + pub const CloseCurlyBracket: Delimiters = Delimiters { bits: 1 << 5 }; + pub const CloseSquareBracket: Delimiters = Delimiters { bits: 1 << 6 }; + pub const CloseParenthesis: Delimiters = Delimiters { bits: 1 << 7 }; +} + +impl BitOr<Delimiters> for Delimiters { + type Output = Delimiters; + + #[inline] + fn bitor(self, other: Delimiters) -> Delimiters { + Delimiters { + bits: self.bits | other.bits, + } + } +} + +impl Delimiters { + #[inline] + fn contains(self, other: Delimiters) -> bool { + (self.bits & other.bits) != 0 + } + + #[inline] + pub(crate) fn from_byte(byte: Option<u8>) -> Delimiters { + const TABLE: [Delimiters; 256] = { + let mut table = [Delimiter::None; 256]; + table[b';' as usize] = Delimiter::Semicolon; + table[b'!' as usize] = Delimiter::Bang; + table[b',' as usize] = Delimiter::Comma; + table[b'{' as usize] = Delimiter::CurlyBracketBlock; + table[b'}' as usize] = ClosingDelimiter::CloseCurlyBracket; + table[b']' as usize] = ClosingDelimiter::CloseSquareBracket; + table[b')' as usize] = ClosingDelimiter::CloseParenthesis; + table + }; + + assert_eq!(TABLE[0], Delimiter::None); + TABLE[byte.unwrap_or(0) as usize] + } +} + +/// Used in some `fn expect_*` methods +macro_rules! expect { + ($parser: ident, $($branches: tt)+) => { + { + let start_location = $parser.current_source_location(); + match *$parser.next()? { + $($branches)+ + ref token => { + return Err(start_location.new_basic_unexpected_token_error(token.clone())) + } + } + } + } +} + +impl<'i: 't, 't> Parser<'i, 't> { + /// Create a new parser + #[inline] + pub fn new(input: &'t mut ParserInput<'i>) -> Parser<'i, 't> { + Parser { + input, + at_start_of: None, + stop_before: Delimiter::None, + } + } + + /// Return the current line that is being parsed. + pub fn current_line(&self) -> &'i str { + self.input.tokenizer.current_source_line() + } + + /// Check whether the input is exhausted. That is, if `.next()` would return a token. + /// + /// This ignores whitespace and comments. + #[inline] + pub fn is_exhausted(&mut self) -> bool { + self.expect_exhausted().is_ok() + } + + /// Check whether the input is exhausted. That is, if `.next()` would return a token. + /// Return a `Result` so that the `?` operator can be used: `input.expect_exhausted()?` + /// + /// This ignores whitespace and comments. + #[inline] + pub fn expect_exhausted(&mut self) -> Result<(), BasicParseError<'i>> { + let start = self.state(); + let result = match self.next() { + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + .. + }) => Ok(()), + Err(e) => unreachable!("Unexpected error encountered: {:?}", e), + Ok(t) => Err(start + .source_location() + .new_basic_unexpected_token_error(t.clone())), + }; + self.reset(&start); + result + } + + /// Return the current position within the input. + /// + /// This can be used with the `Parser::slice` and `slice_from` methods. + #[inline] + pub fn position(&self) -> SourcePosition { + self.input.tokenizer.position() + } + + /// The current line number and column number. + #[inline] + pub fn current_source_location(&self) -> SourceLocation { + self.input.tokenizer.current_source_location() + } + + /// The source map URL, if known. + /// + /// The source map URL is extracted from a specially formatted + /// comment. The last such comment is used, so this value may + /// change as parsing proceeds. + pub fn current_source_map_url(&self) -> Option<&str> { + self.input.tokenizer.current_source_map_url() + } + + /// The source URL, if known. + /// + /// The source URL is extracted from a specially formatted + /// comment. The last such comment is used, so this value may + /// change as parsing proceeds. + pub fn current_source_url(&self) -> Option<&str> { + self.input.tokenizer.current_source_url() + } + + /// Create a new BasicParseError at the current location + #[inline] + pub fn new_basic_error(&self, kind: BasicParseErrorKind<'i>) -> BasicParseError<'i> { + self.current_source_location().new_basic_error(kind) + } + + /// Create a new basic ParseError at the current location + #[inline] + pub fn new_error<E>(&self, kind: BasicParseErrorKind<'i>) -> ParseError<'i, E> { + self.current_source_location().new_error(kind) + } + + /// Create a new custom BasicParseError at the current location + #[inline] + pub fn new_custom_error<E1: Into<E2>, E2>(&self, error: E1) -> ParseError<'i, E2> { + self.current_source_location().new_custom_error(error) + } + + /// Create a new unexpected token BasicParseError at the current location + #[inline] + pub fn new_basic_unexpected_token_error(&self, token: Token<'i>) -> BasicParseError<'i> { + self.new_basic_error(BasicParseErrorKind::UnexpectedToken(token)) + } + + /// Create a new unexpected token ParseError at the current location + #[inline] + pub fn new_unexpected_token_error<E>(&self, token: Token<'i>) -> ParseError<'i, E> { + self.new_error(BasicParseErrorKind::UnexpectedToken(token)) + } + + /// Create a new unexpected token or EOF ParseError at the current location + #[inline] + pub fn new_error_for_next_token<E>(&mut self) -> ParseError<'i, E> { + let token = match self.next() { + Ok(token) => token.clone(), + Err(e) => return e.into(), + }; + self.new_error(BasicParseErrorKind::UnexpectedToken(token)) + } + + /// Return the current internal state of the parser (including position within the input). + /// + /// This state can later be restored with the `Parser::reset` method. + #[inline] + pub fn state(&self) -> ParserState { + ParserState { + at_start_of: self.at_start_of, + ..self.input.tokenizer.state() + } + } + + /// Advance the input until the next token that’s not whitespace or a comment. + #[inline] + pub fn skip_whitespace(&mut self) { + if let Some(block_type) = self.at_start_of.take() { + consume_until_end_of_block(block_type, &mut self.input.tokenizer); + } + + self.input.tokenizer.skip_whitespace() + } + + #[inline] + pub(crate) fn skip_cdc_and_cdo(&mut self) { + if let Some(block_type) = self.at_start_of.take() { + consume_until_end_of_block(block_type, &mut self.input.tokenizer); + } + + self.input.tokenizer.skip_cdc_and_cdo() + } + + #[inline] + pub(crate) fn next_byte(&self) -> Option<u8> { + let byte = self.input.tokenizer.next_byte(); + if self.stop_before.contains(Delimiters::from_byte(byte)) { + return None; + } + byte + } + + /// Restore the internal state of the parser (including position within the input) + /// to what was previously saved by the `Parser::position` method. + /// + /// Should only be used with `SourcePosition` values from the same `Parser` instance. + #[inline] + pub fn reset(&mut self, state: &ParserState) { + self.input.tokenizer.reset(state); + self.at_start_of = state.at_start_of; + } + + /// Start looking for `var()` / `env()` functions. (See the + /// `.seen_var_or_env_functions()` method.) + #[inline] + pub fn look_for_var_or_env_functions(&mut self) { + self.input.tokenizer.look_for_var_or_env_functions() + } + + /// Return whether a `var()` or `env()` function has been seen by the + /// tokenizer since either `look_for_var_or_env_functions` was called, and + /// stop looking. + #[inline] + pub fn seen_var_or_env_functions(&mut self) -> bool { + self.input.tokenizer.seen_var_or_env_functions() + } + + /// The old name of `try_parse`, which requires raw identifiers in the Rust 2018 edition. + #[inline] + pub fn r#try<F, T, E>(&mut self, thing: F) -> Result<T, E> + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>, + { + self.try_parse(thing) + } + + /// Execute the given closure, passing it the parser. + /// If the result (returned unchanged) is `Err`, + /// the internal state of the parser (including position within the input) + /// is restored to what it was before the call. + #[inline] + pub fn try_parse<F, T, E>(&mut self, thing: F) -> Result<T, E> + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, E>, + { + let start = self.state(); + let result = thing(self); + if result.is_err() { + self.reset(&start) + } + result + } + + /// Return a slice of the CSS input + #[inline] + pub fn slice(&self, range: Range<SourcePosition>) -> &'i str { + self.input.tokenizer.slice(range) + } + + /// Return a slice of the CSS input, from the given position to the current one. + #[inline] + pub fn slice_from(&self, start_position: SourcePosition) -> &'i str { + self.input.tokenizer.slice_from(start_position) + } + + /// Return the next token in the input that is neither whitespace or a comment, + /// and advance the position accordingly. + /// + /// After returning a `Function`, `ParenthesisBlock`, + /// `CurlyBracketBlock`, or `SquareBracketBlock` token, + /// the next call will skip until after the matching `CloseParenthesis`, + /// `CloseCurlyBracket`, or `CloseSquareBracket` token. + /// + /// See the `Parser::parse_nested_block` method to parse the content of functions or blocks. + /// + /// This only returns a closing token when it is unmatched (and therefore an error). + #[allow(clippy::should_implement_trait)] + pub fn next(&mut self) -> Result<&Token<'i>, BasicParseError<'i>> { + self.skip_whitespace(); + self.next_including_whitespace_and_comments() + } + + /// Same as `Parser::next`, but does not skip whitespace tokens. + pub fn next_including_whitespace(&mut self) -> Result<&Token<'i>, BasicParseError<'i>> { + loop { + match self.next_including_whitespace_and_comments() { + Err(e) => return Err(e), + Ok(&Token::Comment(_)) => {} + _ => break, + } + } + Ok(self.input.cached_token_ref()) + } + + /// Same as `Parser::next`, but does not skip whitespace or comment tokens. + /// + /// **Note**: This should only be used in contexts like a CSS pre-processor + /// where comments are preserved. + /// When parsing higher-level values, per the CSS Syntax specification, + /// comments should always be ignored between tokens. + pub fn next_including_whitespace_and_comments( + &mut self, + ) -> Result<&Token<'i>, BasicParseError<'i>> { + if let Some(block_type) = self.at_start_of.take() { + consume_until_end_of_block(block_type, &mut self.input.tokenizer); + } + + let byte = self.input.tokenizer.next_byte(); + if self.stop_before.contains(Delimiters::from_byte(byte)) { + return Err(self.new_basic_error(BasicParseErrorKind::EndOfInput)); + } + + let token_start_position = self.input.tokenizer.position(); + let using_cached_token = self + .input + .cached_token + .as_ref() + .map_or(false, |cached_token| { + cached_token.start_position == token_start_position + }); + let token = if using_cached_token { + let cached_token = self.input.cached_token.as_ref().unwrap(); + self.input.tokenizer.reset(&cached_token.end_state); + if let Token::Function(ref name) = cached_token.token { + self.input.tokenizer.see_function(name) + } + &cached_token.token + } else { + let new_token = self + .input + .tokenizer + .next() + .map_err(|()| self.new_basic_error(BasicParseErrorKind::EndOfInput))?; + self.input.cached_token = Some(CachedToken { + token: new_token, + start_position: token_start_position, + end_state: self.input.tokenizer.state(), + }); + self.input.cached_token_ref() + }; + + if let Some(block_type) = BlockType::opening(token) { + self.at_start_of = Some(block_type); + } + Ok(token) + } + + /// Have the given closure parse something, then check the the input is exhausted. + /// The result is overridden to an `Err(..)` if some input remains. + /// + /// This can help tell e.g. `color: green;` from `color: green 4px;` + #[inline] + pub fn parse_entirely<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>> + where + F: FnOnce(&mut Parser<'i, 't>) -> Result<T, ParseError<'i, E>>, + { + let result = parse(self)?; + self.expect_exhausted()?; + Ok(result) + } + + /// Parse a list of comma-separated values, all with the same syntax. + /// + /// The given closure is called repeatedly with a "delimited" parser + /// (see the `Parser::parse_until_before` method) so that it can over + /// consume the input past a comma at this block/function nesting level. + /// + /// Successful results are accumulated in a vector. + /// + /// This method returns an`Err(..)` the first time that a closure call does, + /// or if a closure call leaves some input before the next comma or the end + /// of the input. + #[inline] + pub fn parse_comma_separated<F, T, E>( + &mut self, + parse_one: F, + ) -> Result<Vec<T>, ParseError<'i, E>> + where + F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + self.parse_comma_separated_internal(parse_one, /* ignore_errors = */ false) + } + + /// Like `parse_comma_separated`, but ignores errors on unknown components, + /// rather than erroring out in the whole list. + /// + /// Caller must deal with the fact that the resulting list might be empty, + /// if there's no valid component on the list. + #[inline] + pub fn parse_comma_separated_ignoring_errors<F, T, E: 'i>(&mut self, parse_one: F) -> Vec<T> + where + F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + match self.parse_comma_separated_internal(parse_one, /* ignore_errors = */ true) { + Ok(values) => values, + Err(..) => unreachable!(), + } + } + + #[inline] + fn parse_comma_separated_internal<F, T, E>( + &mut self, + mut parse_one: F, + ignore_errors: bool, + ) -> Result<Vec<T>, ParseError<'i, E>> + where + F: for<'tt> FnMut(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + // Vec grows from 0 to 4 by default on first push(). So allocate with + // capacity 1, so in the somewhat common case of only one item we don't + // way overallocate. Note that we always push at least one item if + // parsing succeeds. + let mut values = Vec::with_capacity(1); + loop { + self.skip_whitespace(); // Unnecessary for correctness, but may help try() in parse_one rewind less. + match self.parse_until_before(Delimiter::Comma, &mut parse_one) { + Ok(v) => values.push(v), + Err(e) if !ignore_errors => return Err(e), + Err(_) => {} + } + match self.next() { + Err(_) => return Ok(values), + Ok(&Token::Comma) => continue, + Ok(_) => unreachable!(), + } + } + } + + /// Parse the content of a block or function. + /// + /// This method panics if the last token yielded by this parser + /// (from one of the `next*` methods) + /// is not a on that marks the start of a block or function: + /// a `Function`, `ParenthesisBlock`, `CurlyBracketBlock`, or `SquareBracketBlock`. + /// + /// The given closure is called with a "delimited" parser + /// that stops at the end of the block or function (at the matching closing token). + /// + /// The result is overridden to an `Err(..)` if the closure leaves some input before that point. + #[inline] + pub fn parse_nested_block<F, T, E>(&mut self, parse: F) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + parse_nested_block(self, parse) + } + + /// Limit parsing to until a given delimiter or the end of the input. (E.g. + /// a semicolon for a property value.) + /// + /// The given closure is called with a "delimited" parser + /// that stops before the first character at this block/function nesting level + /// that matches the given set of delimiters, or at the end of the input. + /// + /// The result is overridden to an `Err(..)` if the closure leaves some input before that point. + #[inline] + pub fn parse_until_before<F, T, E>( + &mut self, + delimiters: Delimiters, + parse: F, + ) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + parse_until_before(self, delimiters, ParseUntilErrorBehavior::Consume, parse) + } + + /// Like `parse_until_before`, but also consume the delimiter token. + /// + /// This can be useful when you don’t need to know which delimiter it was + /// (e.g. if these is only one in the given set) + /// or if it was there at all (as opposed to reaching the end of the input). + #[inline] + pub fn parse_until_after<F, T, E>( + &mut self, + delimiters: Delimiters, + parse: F, + ) -> Result<T, ParseError<'i, E>> + where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, + { + parse_until_after(self, delimiters, ParseUntilErrorBehavior::Consume, parse) + } + + /// Parse a <whitespace-token> and return its value. + #[inline] + pub fn expect_whitespace(&mut self) -> Result<&'i str, BasicParseError<'i>> { + let start_location = self.current_source_location(); + match *self.next_including_whitespace()? { + Token::WhiteSpace(value) => Ok(value), + ref t => Err(start_location.new_basic_unexpected_token_error(t.clone())), + } + } + + /// Parse a <ident-token> and return the unescaped value. + #[inline] + pub fn expect_ident(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::Ident(ref value) => Ok(value), + } + } + + /// expect_ident, but clone the CowRcStr + #[inline] + pub fn expect_ident_cloned(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> { + self.expect_ident().cloned() + } + + /// Parse a <ident-token> whose unescaped value is an ASCII-insensitive match for the given value. + #[inline] + pub fn expect_ident_matching( + &mut self, + expected_value: &str, + ) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Ident(ref value) if value.eq_ignore_ascii_case(expected_value) => Ok(()), + } + } + + /// Parse a <string-token> and return the unescaped value. + #[inline] + pub fn expect_string(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::QuotedString(ref value) => Ok(value), + } + } + + /// expect_string, but clone the CowRcStr + #[inline] + pub fn expect_string_cloned(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> { + self.expect_string().cloned() + } + + /// Parse either a <ident-token> or a <string-token>, and return the unescaped value. + #[inline] + pub fn expect_ident_or_string(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::Ident(ref value) => Ok(value), + Token::QuotedString(ref value) => Ok(value), + } + } + + /// Parse a <url-token> and return the unescaped value. + #[inline] + pub fn expect_url(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::UnquotedUrl(ref value) => Ok(value.clone()), + Token::Function(ref name) if name.eq_ignore_ascii_case("url") => { + self.parse_nested_block(|input| { + input.expect_string().map_err(Into::into).cloned() + }) + .map_err(ParseError::<()>::basic) + } + } + } + + /// Parse either a <url-token> or a <string-token>, and return the unescaped value. + #[inline] + pub fn expect_url_or_string(&mut self) -> Result<CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::UnquotedUrl(ref value) => Ok(value.clone()), + Token::QuotedString(ref value) => Ok(value.clone()), + Token::Function(ref name) if name.eq_ignore_ascii_case("url") => { + self.parse_nested_block(|input| { + input.expect_string().map_err(Into::into).cloned() + }) + .map_err(ParseError::<()>::basic) + } + } + } + + /// Parse a <number-token> and return the integer value. + #[inline] + pub fn expect_number(&mut self) -> Result<f32, BasicParseError<'i>> { + expect! {self, + Token::Number { value, .. } => Ok(value), + } + } + + /// Parse a <number-token> that does not have a fractional part, and return the integer value. + #[inline] + pub fn expect_integer(&mut self) -> Result<i32, BasicParseError<'i>> { + expect! {self, + Token::Number { int_value: Some(int_value), .. } => Ok(int_value), + } + } + + /// Parse a <percentage-token> and return the value. + /// `0%` and `100%` map to `0.0` and `1.0` (not `100.0`), respectively. + #[inline] + pub fn expect_percentage(&mut self) -> Result<f32, BasicParseError<'i>> { + expect! {self, + Token::Percentage { unit_value, .. } => Ok(unit_value), + } + } + + /// Parse a `:` <colon-token>. + #[inline] + pub fn expect_colon(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Colon => Ok(()), + } + } + + /// Parse a `;` <semicolon-token>. + #[inline] + pub fn expect_semicolon(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Semicolon => Ok(()), + } + } + + /// Parse a `,` <comma-token>. + #[inline] + pub fn expect_comma(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Comma => Ok(()), + } + } + + /// Parse a <delim-token> with the given value. + #[inline] + pub fn expect_delim(&mut self, expected_value: char) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Delim(value) if value == expected_value => Ok(()), + } + } + + /// Parse a `{ /* ... */ }` curly brackets block. + /// + /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. + #[inline] + pub fn expect_curly_bracket_block(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::CurlyBracketBlock => Ok(()), + } + } + + /// Parse a `[ /* ... */ ]` square brackets block. + /// + /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. + #[inline] + pub fn expect_square_bracket_block(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::SquareBracketBlock => Ok(()), + } + } + + /// Parse a `( /* ... */ )` parenthesis block. + /// + /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. + #[inline] + pub fn expect_parenthesis_block(&mut self) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::ParenthesisBlock => Ok(()), + } + } + + /// Parse a <function> token and return its name. + /// + /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. + #[inline] + pub fn expect_function(&mut self) -> Result<&CowRcStr<'i>, BasicParseError<'i>> { + expect! {self, + Token::Function(ref name) => Ok(name), + } + } + + /// Parse a <function> token whose name is an ASCII-insensitive match for the given value. + /// + /// If the result is `Ok`, you can then call the `Parser::parse_nested_block` method. + #[inline] + pub fn expect_function_matching( + &mut self, + expected_name: &str, + ) -> Result<(), BasicParseError<'i>> { + expect! {self, + Token::Function(ref name) if name.eq_ignore_ascii_case(expected_name) => Ok(()), + } + } + + /// Parse the input until exhaustion and check that it contains no “error” token. + /// + /// See `Token::is_parse_error`. This also checks nested blocks and functions recursively. + #[inline] + pub fn expect_no_error_token(&mut self) -> Result<(), BasicParseError<'i>> { + loop { + match self.next_including_whitespace_and_comments() { + Ok(&Token::Function(_)) + | Ok(&Token::ParenthesisBlock) + | Ok(&Token::SquareBracketBlock) + | Ok(&Token::CurlyBracketBlock) => self + .parse_nested_block(|input| input.expect_no_error_token().map_err(Into::into)) + .map_err(ParseError::<()>::basic)?, + Ok(t) => { + // FIXME: maybe these should be separate variants of + // BasicParseError instead? + if t.is_parse_error() { + let token = t.clone(); + return Err(self.new_basic_unexpected_token_error(token)); + } + } + Err(_) => return Ok(()), + } + } + } +} + +pub fn parse_until_before<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + delimiters: Delimiters, + error_behavior: ParseUntilErrorBehavior, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ + let delimiters = parser.stop_before | delimiters; + let result; + // Introduce a new scope to limit duration of nested_parser’s borrow + { + let mut delimited_parser = Parser { + input: parser.input, + at_start_of: parser.at_start_of.take(), + stop_before: delimiters, + }; + result = delimited_parser.parse_entirely(parse); + if error_behavior == ParseUntilErrorBehavior::Stop && result.is_err() { + return result; + } + if let Some(block_type) = delimited_parser.at_start_of { + consume_until_end_of_block(block_type, &mut delimited_parser.input.tokenizer); + } + } + // FIXME: have a special-purpose tokenizer method for this that does less work. + loop { + if delimiters.contains(Delimiters::from_byte(parser.input.tokenizer.next_byte())) { + break; + } + if let Ok(token) = parser.input.tokenizer.next() { + if let Some(block_type) = BlockType::opening(&token) { + consume_until_end_of_block(block_type, &mut parser.input.tokenizer); + } + } else { + break; + } + } + result +} + +pub fn parse_until_after<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + delimiters: Delimiters, + error_behavior: ParseUntilErrorBehavior, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ + let result = parse_until_before(parser, delimiters, error_behavior, parse); + if error_behavior == ParseUntilErrorBehavior::Stop && result.is_err() { + return result; + } + let next_byte = parser.input.tokenizer.next_byte(); + if next_byte.is_some() + && !parser + .stop_before + .contains(Delimiters::from_byte(next_byte)) + { + debug_assert!(delimiters.contains(Delimiters::from_byte(next_byte))); + // We know this byte is ASCII. + parser.input.tokenizer.advance(1); + if next_byte == Some(b'{') { + consume_until_end_of_block(BlockType::CurlyBracket, &mut parser.input.tokenizer); + } + } + result +} + +pub fn parse_nested_block<'i: 't, 't, F, T, E>( + parser: &mut Parser<'i, 't>, + parse: F, +) -> Result<T, ParseError<'i, E>> +where + F: for<'tt> FnOnce(&mut Parser<'i, 'tt>) -> Result<T, ParseError<'i, E>>, +{ + let block_type = parser.at_start_of.take().expect( + "\ + A nested parser can only be created when a Function, \ + ParenthesisBlock, SquareBracketBlock, or CurlyBracketBlock \ + token was just consumed.\ + ", + ); + let closing_delimiter = match block_type { + BlockType::CurlyBracket => ClosingDelimiter::CloseCurlyBracket, + BlockType::SquareBracket => ClosingDelimiter::CloseSquareBracket, + BlockType::Parenthesis => ClosingDelimiter::CloseParenthesis, + }; + let result; + // Introduce a new scope to limit duration of nested_parser’s borrow + { + let mut nested_parser = Parser { + input: parser.input, + at_start_of: None, + stop_before: closing_delimiter, + }; + result = nested_parser.parse_entirely(parse); + if let Some(block_type) = nested_parser.at_start_of { + consume_until_end_of_block(block_type, &mut nested_parser.input.tokenizer); + } + } + consume_until_end_of_block(block_type, &mut parser.input.tokenizer); + result +} + +#[inline(never)] +#[cold] +fn consume_until_end_of_block(block_type: BlockType, tokenizer: &mut Tokenizer) { + let mut stack = SmallVec::<[BlockType; 16]>::new(); + stack.push(block_type); + + // FIXME: have a special-purpose tokenizer method for this that does less work. + while let Ok(ref token) = tokenizer.next() { + if let Some(b) = BlockType::closing(token) { + if *stack.last().unwrap() == b { + stack.pop(); + if stack.is_empty() { + return; + } + } + } + + if let Some(block_type) = BlockType::opening(token) { + stack.push(block_type); + } + } +}
diff --git a/src/rules_and_declarations.rs b/src/rules_and_declarations.rs new file mode 100644 index 0000000..bdaef07 --- /dev/null +++ b/src/rules_and_declarations.rs
@@ -0,0 +1,540 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// https://drafts.csswg.org/css-syntax/#parsing + +use super::{BasicParseError, BasicParseErrorKind, Delimiter, ParseError, Parser, Token}; +use crate::cow_rc_str::CowRcStr; +use crate::parser::{parse_nested_block, parse_until_after, ParseUntilErrorBehavior, ParserState}; + +/// Parse `!important`. +/// +/// Typical usage is `input.try_parse(parse_important).is_ok()` +/// at the end of a `DeclarationParser::parse_value` implementation. +pub fn parse_important<'i>(input: &mut Parser<'i, '_>) -> Result<(), BasicParseError<'i>> { + input.expect_delim('!')?; + input.expect_ident_matching("important") +} + +/// A trait to provide various parsing of declaration values. +/// +/// For example, there could be different implementations for property declarations in style rules +/// and for descriptors in `@font-face` rules. +pub trait DeclarationParser<'i> { + /// The finished representation of a declaration. + type Declaration; + + /// The error type that is included in the ParseError value that can be returned. + type Error: 'i; + + /// Parse the value of a declaration with the given `name`. + /// + /// Return the finished representation for the declaration + /// as returned by `DeclarationListParser::next`, + /// or an `Err(..)` to ignore the entire declaration as invalid. + /// + /// Declaration name matching should be case-insensitive in the ASCII range. + /// This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`, + /// or with the `match_ignore_ascii_case!` macro. + /// + /// The given `input` is a "delimited" parser + /// that ends wherever the declaration value should end. + /// (In declaration lists, before the next semicolon or end of the current block.) + /// + /// If `!important` can be used in a given context, + /// `input.try_parse(parse_important).is_ok()` should be used at the end + /// of the implementation of this method and the result should be part of the return value. + fn parse_value<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + _declaration_start: &ParserState, + ) -> Result<Self::Declaration, ParseError<'i, Self::Error>> { + Err(input.new_error(BasicParseErrorKind::UnexpectedToken(Token::Ident(name)))) + } +} + +/// A trait to provide various parsing of at-rules. +/// +/// For example, there could be different implementations for top-level at-rules +/// (`@media`, `@font-face`, …) +/// and for page-margin rules inside `@page`. +/// +/// Default implementations that reject all at-rules are provided, +/// so that `impl AtRuleParser<(), ()> for ... {}` can be used +/// for using `DeclarationListParser` to parse a declarations list with only qualified rules. +pub trait AtRuleParser<'i> { + /// The intermediate representation of prelude of an at-rule. + type Prelude; + + /// The finished representation of an at-rule. + type AtRule; + + /// The error type that is included in the ParseError value that can be returned. + type Error: 'i; + + /// Parse the prelude of an at-rule with the given `name`. + /// + /// Return the representation of the prelude and the type of at-rule, + /// or an `Err(..)` to ignore the entire at-rule as invalid. + /// + /// The prelude is the part after the at-keyword + /// and before the `;` semicolon or `{ /* ... */ }` block. + /// + /// At-rule name matching should be case-insensitive in the ASCII range. + /// This can be done with `std::ascii::Ascii::eq_ignore_ascii_case`, + /// or with the `match_ignore_ascii_case!` macro. + /// + /// The given `input` is a "delimited" parser + /// that ends wherever the prelude should end. + /// (Before the next semicolon, the next `{`, or the end of the current block.) + fn parse_prelude<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> { + Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name))) + } + + /// End an at-rule which doesn't have block. Return the finished + /// representation of the at-rule. + /// + /// The location passed in is source location of the start of the prelude. + /// + /// This is only called when `parse_prelude` returned `WithoutBlock`, and + /// either the `;` semicolon indeed follows the prelude, or parser is at + /// the end of the input. + #[allow(clippy::result_unit_err)] + fn rule_without_block( + &mut self, + prelude: Self::Prelude, + start: &ParserState, + ) -> Result<Self::AtRule, ()> { + let _ = prelude; + let _ = start; + Err(()) + } + + /// Parse the content of a `{ /* ... */ }` block for the body of the at-rule. + /// + /// The location passed in is source location of the start of the prelude. + /// + /// Return the finished representation of the at-rule + /// as returned by `RuleListParser::next` or `DeclarationListParser::next`, + /// or an `Err(..)` to ignore the entire at-rule as invalid. + /// + /// This is only called when `parse_prelude` returned `WithBlock`, and a block + /// was indeed found following the prelude. + fn parse_block<'t>( + &mut self, + prelude: Self::Prelude, + start: &ParserState, + input: &mut Parser<'i, 't>, + ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> { + let _ = prelude; + let _ = start; + Err(input.new_error(BasicParseErrorKind::AtRuleBodyInvalid)) + } +} + +/// A trait to provide various parsing of qualified rules. +/// +/// For example, there could be different implementations for top-level qualified rules (i.e. style +/// rules with Selectors as prelude) and for qualified rules inside `@keyframes` (keyframe rules +/// with keyframe selectors as prelude). +/// +/// Default implementations that reject all qualified rules are provided, so that +/// `impl QualifiedRuleParser<(), ()> for ... {}` can be used for example for using +/// `RuleListParser` to parse a rule list with only at-rules (such as inside +/// `@font-feature-values`). +pub trait QualifiedRuleParser<'i> { + /// The intermediate representation of a qualified rule prelude. + type Prelude; + + /// The finished representation of a qualified rule. + type QualifiedRule; + + /// The error type that is included in the ParseError value that can be returned. + type Error: 'i; + + /// Parse the prelude of a qualified rule. For style rules, this is as Selector list. + /// + /// Return the representation of the prelude, + /// or an `Err(..)` to ignore the entire at-rule as invalid. + /// + /// The prelude is the part before the `{ /* ... */ }` block. + /// + /// The given `input` is a "delimited" parser + /// that ends where the prelude should end (before the next `{`). + fn parse_prelude<'t>( + &mut self, + input: &mut Parser<'i, 't>, + ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> { + Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid)) + } + + /// Parse the content of a `{ /* ... */ }` block for the body of the qualified rule. + /// + /// The location passed in is source location of the start of the prelude. + /// + /// Return the finished representation of the qualified rule + /// as returned by `RuleListParser::next`, + /// or an `Err(..)` to ignore the entire at-rule as invalid. + fn parse_block<'t>( + &mut self, + prelude: Self::Prelude, + start: &ParserState, + input: &mut Parser<'i, 't>, + ) -> Result<Self::QualifiedRule, ParseError<'i, Self::Error>> { + let _ = prelude; + let _ = start; + Err(input.new_error(BasicParseErrorKind::QualifiedRuleInvalid)) + } +} + +/// Provides an iterator for rule bodies and declaration lists. +pub struct RuleBodyParser<'i, 't, 'a, P, I, E> { + /// The input given to the parser. + pub input: &'a mut Parser<'i, 't>, + /// The parser given to `DeclarationListParser::new` + pub parser: &'a mut P, + + _phantom: std::marker::PhantomData<(I, E)>, +} + +/// A parser for a rule body item. +pub trait RuleBodyItemParser<'i, DeclOrRule, Error: 'i>: + DeclarationParser<'i, Declaration = DeclOrRule, Error = Error> + + QualifiedRuleParser<'i, QualifiedRule = DeclOrRule, Error = Error> + + AtRuleParser<'i, AtRule = DeclOrRule, Error = Error> +{ + /// Whether we should attempt to parse declarations. If you know you won't, returning false + /// here is slightly faster. + fn parse_declarations(&self) -> bool; + /// Whether we should attempt to parse qualified rules. If you know you won't, returning false + /// would be slightly faster. + fn parse_qualified(&self) -> bool; +} + +impl<'i, 't, 'a, P, I, E> RuleBodyParser<'i, 't, 'a, P, I, E> { + /// Create a new `DeclarationListParser` for the given `input` and `parser`. + /// + /// Note that all CSS declaration lists can on principle contain at-rules. + /// Even if no such valid at-rule exists (yet), + /// this affects error handling: at-rules end at `{}` blocks, not just semicolons. + /// + /// The given `parser` therefore needs to implement + /// both `DeclarationParser` and `AtRuleParser` traits. + /// However, the latter can be an empty `impl` + /// since `AtRuleParser` provides default implementations of its methods. + /// + /// The return type for finished declarations and at-rules also needs to be the same, + /// since `<DeclarationListParser as Iterator>::next` can return either. + /// It could be a custom enum. + pub fn new(input: &'a mut Parser<'i, 't>, parser: &'a mut P) -> Self { + Self { + input, + parser, + _phantom: std::marker::PhantomData, + } + } +} + +/// https://drafts.csswg.org/css-syntax/#consume-a-blocks-contents +impl<'i, I, P, E: 'i> Iterator for RuleBodyParser<'i, '_, '_, P, I, E> +where + P: RuleBodyItemParser<'i, I, E>, +{ + type Item = Result<I, (ParseError<'i, E>, &'i str)>; + + fn next(&mut self) -> Option<Self::Item> { + loop { + self.input.skip_whitespace(); + let start = self.input.state(); + match self.input.next_including_whitespace_and_comments().ok()? { + Token::CloseCurlyBracket + | Token::WhiteSpace(..) + | Token::Semicolon + | Token::Comment(..) => continue, + Token::AtKeyword(ref name) => { + let name = name.clone(); + return Some(parse_at_rule(&start, name, self.input, &mut *self.parser)); + } + // https://drafts.csswg.org/css-syntax/#consume-a-declaration bails out just to + // keep parsing as a qualified rule if the token is not an ident, so we implement + // that in a slightly more straight-forward way + Token::Ident(ref name) if self.parser.parse_declarations() => { + let name = name.clone(); + let parse_qualified = self.parser.parse_qualified(); + let result = { + let error_behavior = if parse_qualified { + ParseUntilErrorBehavior::Stop + } else { + ParseUntilErrorBehavior::Consume + }; + let parser = &mut self.parser; + parse_until_after( + self.input, + Delimiter::Semicolon, + error_behavior, + |input| { + input.expect_colon()?; + parser.parse_value(name, input, &start) + }, + ) + }; + if result.is_err() && parse_qualified { + self.input.reset(&start); + // We ignore the resulting error here. The property declaration parse error + // is likely to be more relevant. + if let Ok(qual) = parse_qualified_rule( + &start, + self.input, + &mut *self.parser, + /* nested = */ true, + ) { + return Some(Ok(qual)); + } + } + + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); + } + token => { + let result = if self.parser.parse_qualified() { + self.input.reset(&start); + let nested = self.parser.parse_declarations(); + parse_qualified_rule(&start, self.input, &mut *self.parser, nested) + } else { + let token = token.clone(); + self.input.parse_until_after(Delimiter::Semicolon, |_| { + Err(start.source_location().new_unexpected_token_error(token)) + }) + }; + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); + } + } + } + } +} + +/// Provides an iterator for rule list parsing at the top-level of a stylesheet. +pub struct StyleSheetParser<'i, 't, 'a, P> { + /// The input given. + pub input: &'a mut Parser<'i, 't>, + + /// The parser given. + pub parser: &'a mut P, + + any_rule_so_far: bool, +} + +impl<'i, 't, 'a, R, P, E: 'i> StyleSheetParser<'i, 't, 'a, P> +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ + /// The given `parser` needs to implement both `QualifiedRuleParser` and `AtRuleParser` traits. + /// However, either of them can be an empty `impl` since the traits provide default + /// implementations of their methods. + /// + /// The return type for finished qualified rules and at-rules also needs to be the same, + /// since `<RuleListParser as Iterator>::next` can return either. It could be a custom enum. + pub fn new(input: &'a mut Parser<'i, 't>, parser: &'a mut P) -> Self { + Self { + input, + parser, + any_rule_so_far: false, + } + } +} + +/// `RuleListParser` is an iterator that yields `Ok(_)` for a rule or an `Err(..)` for an invalid one. +impl<'i, R, P, E: 'i> Iterator for StyleSheetParser<'i, '_, '_, P> +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ + type Item = Result<R, (ParseError<'i, E>, &'i str)>; + + fn next(&mut self) -> Option<Self::Item> { + loop { + self.input.skip_cdc_and_cdo(); + let start = self.input.state(); + let at_keyword = match self.input.next_byte()? { + b'@' => match self.input.next_including_whitespace_and_comments() { + Ok(Token::AtKeyword(name)) => Some(name.clone()), + _ => { + self.input.reset(&start); + None + } + }, + _ => None, + }; + + if let Some(name) = at_keyword { + let first_stylesheet_rule = !self.any_rule_so_far; + self.any_rule_so_far = true; + if first_stylesheet_rule && name.eq_ignore_ascii_case("charset") { + let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock; + let _: Result<(), ParseError<()>> = + self.input.parse_until_after(delimiters, |_| Ok(())); + } else { + return Some(parse_at_rule( + &start, + name.clone(), + self.input, + &mut *self.parser, + )); + } + } else { + self.any_rule_so_far = true; + let result = parse_qualified_rule( + &start, + self.input, + &mut *self.parser, + /* nested = */ false, + ); + return Some(result.map_err(|e| (e, self.input.slice_from(start.position())))); + } + } + } +} + +/// Parse a single declaration, such as an `( /* ... */ )` parenthesis in an `@supports` prelude. +pub fn parse_one_declaration<'i, 't, P, E>( + input: &mut Parser<'i, 't>, + parser: &mut P, +) -> Result<<P as DeclarationParser<'i>>::Declaration, (ParseError<'i, E>, &'i str)> +where + P: DeclarationParser<'i, Error = E>, +{ + let start = input.state(); + let start_position = input.position(); + input + .parse_entirely(|input| { + let name = input.expect_ident()?.clone(); + input.expect_colon()?; + parser.parse_value(name, input, &start) + }) + .map_err(|e| (e, input.slice_from(start_position))) +} + +/// Parse a single rule, such as for CSSOM’s `CSSStyleSheet.insertRule`. +pub fn parse_one_rule<'i, 't, R, P, E>( + input: &mut Parser<'i, 't>, + parser: &mut P, +) -> Result<R, ParseError<'i, E>> +where + P: QualifiedRuleParser<'i, QualifiedRule = R, Error = E> + + AtRuleParser<'i, AtRule = R, Error = E>, +{ + input.parse_entirely(|input| { + input.skip_whitespace(); + let start = input.state(); + let at_keyword = if input.next_byte() == Some(b'@') { + match *input.next_including_whitespace_and_comments()? { + Token::AtKeyword(ref name) => Some(name.clone()), + _ => { + input.reset(&start); + None + } + } + } else { + None + }; + + if let Some(name) = at_keyword { + parse_at_rule(&start, name, input, parser).map_err(|e| e.0) + } else { + parse_qualified_rule(&start, input, parser, /* nested = */ false) + } + }) +} + +fn parse_at_rule<'i, 't, P, E>( + start: &ParserState, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + parser: &mut P, +) -> Result<<P as AtRuleParser<'i>>::AtRule, (ParseError<'i, E>, &'i str)> +where + P: AtRuleParser<'i, Error = E>, +{ + let delimiters = Delimiter::Semicolon | Delimiter::CurlyBracketBlock; + let result = input.parse_until_before(delimiters, |input| parser.parse_prelude(name, input)); + match result { + Ok(prelude) => { + let result = match input.next() { + Ok(&Token::Semicolon) | Err(_) => parser + .rule_without_block(prelude, start) + .map_err(|()| input.new_unexpected_token_error(Token::Semicolon)), + Ok(&Token::CurlyBracketBlock) => { + parse_nested_block(input, |input| parser.parse_block(prelude, start, input)) + } + Ok(_) => unreachable!(), + }; + result.map_err(|e| (e, input.slice_from(start.position()))) + } + Err(error) => { + let end_position = input.position(); + match input.next() { + Ok(&Token::CurlyBracketBlock) | Ok(&Token::Semicolon) | Err(_) => {} + _ => unreachable!(), + }; + Err((error, input.slice(start.position()..end_position))) + } + } +} + +// If the first two non-<whitespace-token> values of rule’s prelude are an <ident-token> whose +// value starts with "--" followed by a <colon-token>, then... +fn looks_like_a_custom_property(input: &mut Parser) -> bool { + let ident = match input.expect_ident() { + Ok(i) => i, + Err(..) => return false, + }; + ident.starts_with("--") && input.expect_colon().is_ok() +} + +// https://drafts.csswg.org/css-syntax/#consume-a-qualified-rule +fn parse_qualified_rule<'i, 't, P, E>( + start: &ParserState, + input: &mut Parser<'i, 't>, + parser: &mut P, + nested: bool, +) -> Result<<P as QualifiedRuleParser<'i>>::QualifiedRule, ParseError<'i, E>> +where + P: QualifiedRuleParser<'i, Error = E>, +{ + input.skip_whitespace(); + let prelude = { + let state = input.state(); + if looks_like_a_custom_property(input) { + // If nested is true, consume the remnants of a bad declaration from input, with + // nested set to true, and return nothing. + // If nested is false, consume a block from input, and return nothing. + let delimiters = if nested { + Delimiter::Semicolon + } else { + Delimiter::CurlyBracketBlock + }; + let _: Result<(), ParseError<()>> = input.parse_until_after(delimiters, |_| Ok(())); + return Err(state + .source_location() + .new_error(BasicParseErrorKind::QualifiedRuleInvalid)); + } + let delimiters = if nested { + Delimiter::Semicolon | Delimiter::CurlyBracketBlock + } else { + Delimiter::CurlyBracketBlock + }; + input.reset(&state); + input.parse_until_before(delimiters, |input| parser.parse_prelude(input)) + }; + + input.expect_curly_bracket_block()?; + // Do this here so that we consume the `{` even if the prelude is `Err`. + let prelude = prelude?; + parse_nested_block(input, |input| parser.parse_block(prelude, start, input)) +}
diff --git a/src/serializer.rs b/src/serializer.rs new file mode 100644 index 0000000..6696a62 --- /dev/null +++ b/src/serializer.rs
@@ -0,0 +1,594 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::match_byte; +use dtoa_short::Notation; +use std::fmt::{self, Write}; +use std::str; + +use super::Token; + +/// Trait for things the can serialize themselves in CSS syntax. +pub trait ToCss { + /// Serialize `self` in CSS syntax, writing to `dest`. + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write; + + /// Serialize `self` in CSS syntax and return a string. + /// + /// (This is a convenience wrapper for `to_css` and probably should not be overridden.) + #[inline] + fn to_css_string(&self) -> String { + let mut s = String::new(); + self.to_css(&mut s).unwrap(); + s + } +} + +#[inline] +fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + // `value.value >= 0` is true for negative 0. + if has_sign && value.is_sign_positive() { + dest.write_str("+")?; + } + + let notation = if value == 0.0 && value.is_sign_negative() { + // Negative zero. Work around #20596. + dest.write_str("-0")?; + Notation { + decimal_point: false, + scientific: false, + } + } else { + dtoa_short::write(dest, value)? + }; + + if int_value.is_none() && value.fract() == 0. && !notation.decimal_point && !notation.scientific + { + dest.write_str(".0")?; + } + Ok(()) +} + +impl ToCss for Token<'_> { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + match *self { + Token::Ident(ref value) => serialize_identifier(value, dest)?, + Token::AtKeyword(ref value) => { + dest.write_str("@")?; + serialize_identifier(value, dest)?; + } + Token::Hash(ref value) => { + dest.write_str("#")?; + serialize_name(value, dest)?; + } + Token::IDHash(ref value) => { + dest.write_str("#")?; + serialize_identifier(value, dest)?; + } + Token::QuotedString(ref value) => serialize_string(value, dest)?, + Token::UnquotedUrl(ref value) => { + dest.write_str("url(")?; + serialize_unquoted_url(value, dest)?; + dest.write_str(")")?; + } + Token::Delim(value) => dest.write_char(value)?, + + Token::Number { + value, + int_value, + has_sign, + } => write_numeric(value, int_value, has_sign, dest)?, + Token::Percentage { + unit_value, + int_value, + has_sign, + } => { + write_numeric(unit_value * 100., int_value, has_sign, dest)?; + dest.write_str("%")?; + } + Token::Dimension { + value, + int_value, + has_sign, + ref unit, + } => { + write_numeric(value, int_value, has_sign, dest)?; + // Disambiguate with scientific notation. + let unit = &**unit; + // TODO(emilio): This doesn't handle e.g. 100E1m, which gets us + // an unit of "E1m"... + if unit == "e" || unit == "E" || unit.starts_with("e-") || unit.starts_with("E-") { + dest.write_str("\\65 ")?; + serialize_name(&unit[1..], dest)?; + } else { + serialize_identifier(unit, dest)?; + } + } + + Token::WhiteSpace(content) => dest.write_str(content)?, + Token::Comment(content) => { + dest.write_str("/*")?; + dest.write_str(content)?; + dest.write_str("*/")? + } + Token::Colon => dest.write_str(":")?, + Token::Semicolon => dest.write_str(";")?, + Token::Comma => dest.write_str(",")?, + Token::IncludeMatch => dest.write_str("~=")?, + Token::DashMatch => dest.write_str("|=")?, + Token::PrefixMatch => dest.write_str("^=")?, + Token::SuffixMatch => dest.write_str("$=")?, + Token::SubstringMatch => dest.write_str("*=")?, + Token::CDO => dest.write_str("<!--")?, + Token::CDC => dest.write_str("-->")?, + + Token::Function(ref name) => { + serialize_identifier(name, dest)?; + dest.write_str("(")?; + } + Token::ParenthesisBlock => dest.write_str("(")?, + Token::SquareBracketBlock => dest.write_str("[")?, + Token::CurlyBracketBlock => dest.write_str("{")?, + + Token::BadUrl(ref contents) => { + dest.write_str("url(")?; + dest.write_str(contents)?; + dest.write_char(')')?; + } + Token::BadString(ref value) => { + // During tokenization, an unescaped newline after a quote causes + // the token to be a BadString instead of a QuotedString. + // The BadString token ends just before the newline + // (which is in a separate WhiteSpace token), + // and therefore does not have a closing quote. + dest.write_char('"')?; + CssStringWriter::new(dest).write_str(value)?; + } + Token::CloseParenthesis => dest.write_str(")")?, + Token::CloseSquareBracket => dest.write_str("]")?, + Token::CloseCurlyBracket => dest.write_str("}")?, + } + Ok(()) + } +} + +fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + static HEX_DIGITS: &[u8; 16] = b"0123456789abcdef"; + let b3; + let b4; + let bytes = if ascii_byte > 0x0F { + let high = (ascii_byte >> 4) as usize; + let low = (ascii_byte & 0x0F) as usize; + b4 = [b'\\', HEX_DIGITS[high], HEX_DIGITS[low], b' ']; + &b4[..] + } else { + b3 = [b'\\', HEX_DIGITS[ascii_byte as usize], b' ']; + &b3[..] + }; + dest.write_str(unsafe { str::from_utf8_unchecked(bytes) }) +} + +fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + let bytes = [b'\\', ascii_byte]; + dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) }) +} + +/// Write a CSS identifier, escaping characters as necessary. +pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + if value.is_empty() { + return Ok(()); + } + + if let Some(value) = value.strip_prefix("--") { + dest.write_str("--")?; + serialize_name(value, dest) + } else if value == "-" { + dest.write_str("\\-") + } else { + if value.as_bytes()[0] == b'-' { + dest.write_str("-")?; + value = &value[1..]; + } + if let digit @ b'0'..=b'9' = value.as_bytes()[0] { + hex_escape(digit, dest)?; + value = &value[1..]; + } + serialize_name(value, dest) + } +} + +/// Write a CSS name, like a custom property name. +/// +/// You should only use this when you know what you're doing, when in doubt, +/// consider using `serialize_identifier`. +pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + let mut chunk_start = 0; + for (i, b) in value.bytes().enumerate() { + let escaped = match_byte! { b, + b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' | b'_' | b'-' => continue, + b'\0' => Some("\u{FFFD}"), + b => { + if !b.is_ascii() { + continue; + } + None + }, + }; + dest.write_str(&value[chunk_start..i])?; + if let Some(escaped) = escaped { + dest.write_str(escaped)?; + } else if (b'\x01'..=b'\x1F').contains(&b) || b == b'\x7F' { + hex_escape(b, dest)?; + } else { + char_escape(b, dest)?; + } + chunk_start = i + 1; + } + dest.write_str(&value[chunk_start..]) +} + +fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + let mut chunk_start = 0; + for (i, b) in value.bytes().enumerate() { + let hex = match_byte! { b, + b'\0'..=b' ' | b'\x7F' => true, + b'(' | b')' | b'"' | b'\'' | b'\\' => false, + _ => continue, + }; + dest.write_str(&value[chunk_start..i])?; + if hex { + hex_escape(b, dest)?; + } else { + char_escape(b, dest)?; + } + chunk_start = i + 1; + } + dest.write_str(&value[chunk_start..]) +} + +/// Write a double-quoted CSS string token, escaping content as necessary. +pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result +where + W: fmt::Write, +{ + dest.write_str("\"")?; + CssStringWriter::new(dest).write_str(value)?; + dest.write_str("\"")?; + Ok(()) +} + +/// A `fmt::Write` adapter that escapes text for writing as a double-quoted CSS string. +/// Quotes are not included. +/// +/// Typical usage: +/// +/// ```{rust,ignore} +/// fn write_foo<W>(foo: &Foo, dest: &mut W) -> fmt::Result where W: fmt::Write { +/// dest.write_str("\"")?; +/// { +/// let mut string_dest = CssStringWriter::new(dest); +/// // Write into string_dest... +/// } +/// dest.write_str("\"")?; +/// Ok(()) +/// } +/// ``` +pub struct CssStringWriter<'a, W> { + inner: &'a mut W, +} + +impl<'a, W> CssStringWriter<'a, W> +where + W: fmt::Write, +{ + /// Wrap a text writer to create a `CssStringWriter`. + pub fn new(inner: &'a mut W) -> CssStringWriter<'a, W> { + CssStringWriter { inner } + } +} + +impl<W> fmt::Write for CssStringWriter<'_, W> +where + W: fmt::Write, +{ + fn write_str(&mut self, s: &str) -> fmt::Result { + let mut chunk_start = 0; + for (i, b) in s.bytes().enumerate() { + let escaped = match_byte! { b, + b'"' => Some("\\\""), + b'\\' => Some("\\\\"), + b'\0' => Some("\u{FFFD}"), + b'\x01'..=b'\x1F' | b'\x7F' => None, + _ => continue, + }; + self.inner.write_str(&s[chunk_start..i])?; + match escaped { + Some(x) => self.inner.write_str(x)?, + None => hex_escape(b, self.inner)?, + }; + chunk_start = i + 1; + } + self.inner.write_str(&s[chunk_start..]) + } +} + +macro_rules! impl_tocss_for_int { + ($T: ty) => { + impl ToCss for $T { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + let mut buf = itoa::Buffer::new(); + dest.write_str(buf.format(*self)) + } + } + }; +} + +impl_tocss_for_int!(i8); +impl_tocss_for_int!(u8); +impl_tocss_for_int!(i16); +impl_tocss_for_int!(u16); +impl_tocss_for_int!(i32); +impl_tocss_for_int!(u32); +impl_tocss_for_int!(i64); +impl_tocss_for_int!(u64); + +macro_rules! impl_tocss_for_float { + ($T: ty) => { + impl ToCss for $T { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + dtoa_short::write(dest, *self).map(|_| ()) + } + } + }; +} + +impl_tocss_for_float!(f32); +impl_tocss_for_float!(f64); + +/// A category of token. See the `needs_separator_when_before` method. +#[derive(Copy, Clone, Eq, PartialEq, Debug, Default)] +pub enum TokenSerializationType { + /// No token serialization type. + #[default] + Nothing, + + /// The [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram) + /// type. + WhiteSpace, + + /// The [`<at-keyword-token>`](https://drafts.csswg.org/css-syntax/#at-keyword-token-diagram) + /// type, the "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with + /// the type flag set to 'unrestricted'" type, or the + /// "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type + /// flag set to 'id'" type. + AtKeywordOrHash, + + /// The [`<number-token>`](https://drafts.csswg.org/css-syntax/#number-token-diagram) type. + Number, + + /// The [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram) + /// type. + Dimension, + + /// The [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram) + /// type. + Percentage, + + /// The [`<url-token>`](https://drafts.csswg.org/css-syntax/#url-token-diagram) or + /// `<bad-url-token>` type. + UrlOrBadUrl, + + /// The [`<function-token>`](https://drafts.csswg.org/css-syntax/#function-token-diagram) type. + Function, + + /// The [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram) type. + Ident, + + /// The `-->` [`<CDC-token>`](https://drafts.csswg.org/css-syntax/#CDC-token-diagram) type. + CDC, + + /// The `|=` + /// [`<dash-match-token>`](https://drafts.csswg.org/css-syntax/#dash-match-token-diagram) type. + DashMatch, + + /// The `*=` + /// [`<substring-match-token>`](https://drafts.csswg.org/css-syntax/#substring-match-token-diagram) + /// type. + SubstringMatch, + + /// The `<(-token>` type. + OpenParen, + + /// The `#` `<delim-token>` type. + DelimHash, + + /// The `@` `<delim-token>` type. + DelimAt, + + /// The `.` or `+` `<delim-token>` type. + DelimDotOrPlus, + + /// The `-` `<delim-token>` type. + DelimMinus, + + /// The `?` `<delim-token>` type. + DelimQuestion, + + /// The `$`, `^`, or `~` `<delim-token>` type. + DelimAssorted, + + /// The `=` `<delim-token>` type. + DelimEquals, + + /// The `|` `<delim-token>` type. + DelimBar, + + /// The `/` `<delim-token>` type. + DelimSlash, + + /// The `*` `<delim-token>` type. + DelimAsterisk, + + /// The `%` `<delim-token>` type. + DelimPercent, + + /// A type indicating any other token. + Other, +} + +#[cfg(feature = "malloc_size_of")] +malloc_size_of::malloc_size_of_is_0!(TokenSerializationType); + +impl TokenSerializationType { + /// Return a value that represents the absence of a token, e.g. before the start of the input. + #[deprecated( + since = "0.32.1", + note = "use TokenSerializationType::Nothing or TokenSerializationType::default() instead" + )] + pub fn nothing() -> TokenSerializationType { + Default::default() + } + + /// If this value is `TokenSerializationType::Nothing`, set it to the given value instead. + pub fn set_if_nothing(&mut self, new_value: TokenSerializationType) { + if matches!(self, TokenSerializationType::Nothing) { + *self = new_value + } + } + + /// Return true if, when a token of category `self` is serialized just before + /// a token of category `other` with no whitespace in between, + /// an empty comment `/**/` needs to be inserted between them + /// so that they are not re-parsed as a single token. + /// + /// See https://drafts.csswg.org/css-syntax/#serialization + /// + /// See https://github.com/w3c/csswg-drafts/issues/4088 for the + /// `DelimPercent` bits. + pub fn needs_separator_when_before(self, other: TokenSerializationType) -> bool { + use self::TokenSerializationType::*; + match self { + Ident => matches!( + other, + Ident + | Function + | UrlOrBadUrl + | DelimMinus + | Number + | Percentage + | Dimension + | CDC + | OpenParen + ), + AtKeywordOrHash | Dimension => matches!( + other, + Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | CDC + ), + DelimHash | DelimMinus => matches!( + other, + Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension + ), + Number => matches!( + other, + Ident + | Function + | UrlOrBadUrl + | DelimMinus + | Number + | Percentage + | DelimPercent + | Dimension + ), + DelimAt => matches!(other, Ident | Function | UrlOrBadUrl | DelimMinus), + DelimDotOrPlus => matches!(other, Number | Percentage | Dimension), + DelimAssorted | DelimAsterisk => matches!(other, DelimEquals), + DelimBar => matches!(other, DelimEquals | DelimBar | DashMatch), + DelimSlash => matches!(other, DelimAsterisk | SubstringMatch), + Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen + | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => { + false + } + } + } +} + +impl Token<'_> { + /// Categorize a token into a type that determines when `/**/` needs to be inserted + /// between two tokens when serialized next to each other without whitespace in between. + /// + /// See the `TokenSerializationType::needs_separator_when_before` method. + pub fn serialization_type(&self) -> TokenSerializationType { + use self::TokenSerializationType::*; + match self { + Token::Ident(_) => Ident, + Token::AtKeyword(_) | Token::Hash(_) | Token::IDHash(_) => AtKeywordOrHash, + Token::UnquotedUrl(_) | Token::BadUrl(_) => UrlOrBadUrl, + Token::Delim('#') => DelimHash, + Token::Delim('@') => DelimAt, + Token::Delim('.') | Token::Delim('+') => DelimDotOrPlus, + Token::Delim('-') => DelimMinus, + Token::Delim('?') => DelimQuestion, + Token::Delim('$') | Token::Delim('^') | Token::Delim('~') => DelimAssorted, + Token::Delim('%') => DelimPercent, + Token::Delim('=') => DelimEquals, + Token::Delim('|') => DelimBar, + Token::Delim('/') => DelimSlash, + Token::Delim('*') => DelimAsterisk, + Token::Number { .. } => Number, + Token::Percentage { .. } => Percentage, + Token::Dimension { .. } => Dimension, + Token::WhiteSpace(_) => WhiteSpace, + Token::Comment(_) => DelimSlash, + Token::DashMatch => DashMatch, + Token::SubstringMatch => SubstringMatch, + Token::CDC => CDC, + Token::Function(_) => Function, + Token::ParenthesisBlock => OpenParen, + Token::SquareBracketBlock + | Token::CurlyBracketBlock + | Token::CloseParenthesis + | Token::CloseSquareBracket + | Token::CloseCurlyBracket + | Token::QuotedString(_) + | Token::BadString(_) + | Token::Delim(_) + | Token::Colon + | Token::Semicolon + | Token::Comma + | Token::CDO + | Token::IncludeMatch + | Token::PrefixMatch + | Token::SuffixMatch => Other, + } + } +}
diff --git a/src/size_of_tests.rs b/src/size_of_tests.rs new file mode 100644 index 0000000..edd2b43 --- /dev/null +++ b/src/size_of_tests.rs
@@ -0,0 +1,52 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +use crate::cow_rc_str::CowRcStr; +use crate::tokenizer::Token; + +macro_rules! size_of_test { + ($testname: ident, $t: ty, $expected_min_size: expr, $expected_max_size: expr) => { + #[test] + fn $testname() { + let new = ::std::mem::size_of::<$t>(); + if new < $expected_min_size { + panic!( + "Your changes have decreased the stack size of {} from {} to {}. \ + Good work! Please update the expected size in {}.", + stringify!($t), + $expected_min_size, + new, + file!() + ) + } else if new > $expected_max_size { + panic!( + "Your changes have increased the stack size of {} from {} to {}. \ + Please consider choosing a design which avoids this increase. \ + If you feel that the increase is necessary, update the size in {}.", + stringify!($t), + $expected_max_size, + new, + file!() + ) + } + } + }; + ($testname: ident, $t: ty, $expected_size: expr) => { + size_of_test!($testname, $t, $expected_size, $expected_size); + }; +} + +// Some of these assume 64-bit +size_of_test!(token, Token, 32); +size_of_test!(std_cow_str, std::borrow::Cow<'static, str>, 24, 32); +size_of_test!(cow_rc_str, CowRcStr, 16); + +size_of_test!(tokenizer, crate::tokenizer::Tokenizer, 72); +size_of_test!(parser_input, crate::parser::ParserInput, 136); +size_of_test!(parser, crate::parser::Parser, 16); +size_of_test!(source_position, crate::SourcePosition, 8); +size_of_test!(parser_state, crate::ParserState, 24); + +size_of_test!(basic_parse_error, crate::BasicParseError, 40, 48); +size_of_test!(parse_error_lower_bound, crate::ParseError<()>, 40, 48);
diff --git a/src/tests.rs b/src/tests.rs new file mode 100644 index 0000000..3c122f0 --- /dev/null +++ b/src/tests.rs
@@ -0,0 +1,1353 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#[cfg(feature = "bench")] +extern crate test; + +use serde_json::{json, Map, Value}; + +#[cfg(feature = "bench")] +use self::test::Bencher; + +use super::{ + parse_important, parse_nth, parse_one_declaration, parse_one_rule, stylesheet_encoding, + AtRuleParser, BasicParseError, BasicParseErrorKind, CowRcStr, DeclarationParser, Delimiter, + EncodingSupport, ParseError, ParseErrorKind, Parser, ParserInput, ParserState, + QualifiedRuleParser, RuleBodyItemParser, RuleBodyParser, SourceLocation, StyleSheetParser, + ToCss, Token, TokenSerializationType, UnicodeRange, +}; + +macro_rules! JArray { + ($($e: expr,)*) => { JArray![ $( $e ),* ] }; + ($($e: expr),*) => { Value::Array(vec!( $( $e.to_json() ),* )) } +} + +fn almost_equals(a: &Value, b: &Value) -> bool { + let var_name = match (a, b) { + (Value::Number(a), Value::Number(b)) => { + let a = a.as_f64().unwrap(); + let b = b.as_f64().unwrap(); + (a - b).abs() <= a.abs() * 1e-6 + } + + (&Value::Bool(a), &Value::Bool(b)) => a == b, + (Value::String(a), Value::String(b)) => a == b, + (Value::Array(a), Value::Array(b)) => { + a.len() == b.len() && a.iter().zip(b.iter()).all(|(a, b)| almost_equals(a, b)) + } + (&Value::Object(_), &Value::Object(_)) => panic!("Not implemented"), + (&Value::Null, &Value::Null) => true, + _ => false, + }; + var_name +} + +fn normalize(json: &mut Value) { + match *json { + Value::Array(ref mut list) => { + for item in list.iter_mut() { + normalize(item) + } + } + Value::String(ref mut s) => { + if *s == "extra-input" || *s == "empty" { + *s = "invalid".to_string() + } + } + _ => {} + } +} + +fn assert_json_eq(results: Value, mut expected: Value, message: &str) { + normalize(&mut expected); + if !almost_equals(&results, &expected) { + println!( + "{}", + ::difference::Changeset::new( + &serde_json::to_string_pretty(&results).unwrap(), + &serde_json::to_string_pretty(&expected).unwrap(), + "\n", + ) + ); + panic!("{}", message) + } +} + +fn run_raw_json_tests<F: Fn(Value, Value)>(json_data: &str, run: F) { + let items = match serde_json::from_str(json_data) { + Ok(Value::Array(items)) => items, + other => panic!("Invalid JSON: {:?}", other), + }; + assert!(items.len() % 2 == 0); + let mut input = None; + for item in items.into_iter() { + match (&input, item) { + (&None, json_obj) => input = Some(json_obj), + (&Some(_), expected) => { + let input = input.take().unwrap(); + run(input, expected) + } + }; + } +} + +fn run_json_tests<F: Fn(&mut Parser) -> Value>(json_data: &str, parse: F) { + run_raw_json_tests(json_data, |input, expected| match input { + Value::String(input) => { + let mut parse_input = ParserInput::new(&input); + let result = parse(&mut Parser::new(&mut parse_input)); + assert_json_eq(result, expected, &input); + } + _ => panic!("Unexpected JSON"), + }); +} + +#[test] +fn component_value_list() { + run_json_tests( + include_str!("css-parsing-tests/component_value_list.json"), + |input| Value::Array(component_values_to_json(input)), + ); +} + +#[test] +fn one_component_value() { + run_json_tests( + include_str!("css-parsing-tests/one_component_value.json"), + |input| { + let result: Result<Value, ParseError<()>> = input.parse_entirely(|input| { + Ok(one_component_value_to_json(input.next()?.clone(), input)) + }); + result.unwrap_or(JArray!["error", "invalid"]) + }, + ); +} + +#[test] +fn declaration_list() { + run_json_tests( + include_str!("css-parsing-tests/declaration_list.json"), + |input| { + Value::Array( + RuleBodyParser::new(input, &mut JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) + }, + ); +} + +#[test] +fn one_declaration() { + run_json_tests( + include_str!("css-parsing-tests/one_declaration.json"), + |input| { + parse_one_declaration(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"]) + }, + ); +} + +#[test] +fn rule_list() { + run_json_tests(include_str!("css-parsing-tests/rule_list.json"), |input| { + Value::Array( + RuleBodyParser::new(input, &mut JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) + }); +} + +#[test] +fn stylesheet() { + run_json_tests(include_str!("css-parsing-tests/stylesheet.json"), |input| { + Value::Array( + StyleSheetParser::new(input, &mut JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect(), + ) + }); +} + +#[test] +fn one_rule() { + run_json_tests(include_str!("css-parsing-tests/one_rule.json"), |input| { + parse_one_rule(input, &mut JsonParser).unwrap_or(JArray!["error", "invalid"]) + }); +} + +#[test] +fn stylesheet_from_bytes() { + pub struct EncodingRs; + + impl EncodingSupport for EncodingRs { + type Encoding = &'static encoding_rs::Encoding; + + fn utf8() -> Self::Encoding { + encoding_rs::UTF_8 + } + + fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool { + *encoding == encoding_rs::UTF_16LE || *encoding == encoding_rs::UTF_16BE + } + + fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding> { + encoding_rs::Encoding::for_label(ascii_label) + } + } + + run_raw_json_tests( + include_str!("css-parsing-tests/stylesheet_bytes.json"), + |input, expected| { + let map = match input { + Value::Object(map) => map, + _ => panic!("Unexpected JSON"), + }; + + let result = { + let css = get_string(&map, "css_bytes") + .unwrap() + .chars() + .map(|c| { + assert!(c as u32 <= 0xFF); + c as u8 + }) + .collect::<Vec<u8>>(); + let protocol_encoding_label = + get_string(&map, "protocol_encoding").map(|s| s.as_bytes()); + let environment_encoding = get_string(&map, "environment_encoding") + .map(|s| s.as_bytes()) + .and_then(EncodingRs::from_label); + + let encoding = stylesheet_encoding::<EncodingRs>( + &css, + protocol_encoding_label, + environment_encoding, + ); + let (css_unicode, used_encoding, _) = encoding.decode(&css); + let mut input = ParserInput::new(&css_unicode); + let input = &mut Parser::new(&mut input); + let rules = StyleSheetParser::new(input, &mut JsonParser) + .map(|result| result.unwrap_or(JArray!["error", "invalid"])) + .collect::<Vec<_>>(); + JArray![rules, used_encoding.name().to_lowercase()] + }; + assert_json_eq(result, expected, &Value::Object(map).to_string()); + }, + ); + + fn get_string<'a>(map: &'a Map<String, Value>, key: &str) -> Option<&'a str> { + match map.get(key) { + Some(Value::String(s)) => Some(s), + Some(&Value::Null) => None, + None => None, + _ => panic!("Unexpected JSON"), + } + } +} + +#[test] +fn expect_no_error_token() { + let mut input = ParserInput::new("foo 4px ( / { !bar }"); + assert!(Parser::new(&mut input).expect_no_error_token().is_ok()); + let mut input = ParserInput::new(")"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("}"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("(a){]"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("'\n'"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("url('\n'"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("url(a b)"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); + let mut input = ParserInput::new("url(\u{7F}))"); + assert!(Parser::new(&mut input).expect_no_error_token().is_err()); +} + +/// https://github.com/servo/rust-cssparser/issues/71 +#[test] +fn outer_block_end_consumed() { + let mut input = ParserInput::new("(calc(true))"); + let mut input = Parser::new(&mut input); + assert!(input.expect_parenthesis_block().is_ok()); + assert!(input + .parse_nested_block(|input| input + .expect_function_matching("calc") + .map_err(Into::<ParseError<()>>::into)) + .is_ok()); + println!("{:?}", input.position()); + assert!(input.next().is_err()); +} + +/// https://github.com/servo/rust-cssparser/issues/174 +#[test] +fn bad_url_slice_out_of_bounds() { + let mut input = ParserInput::new("url(\u{1}\\"); + let mut parser = Parser::new(&mut input); + let result = parser.next_including_whitespace_and_comments(); // This used to panic + assert_eq!(result, Ok(&Token::BadUrl("\u{1}\\".into()))); +} + +/// https://bugzilla.mozilla.org/show_bug.cgi?id=1383975 +#[test] +fn bad_url_slice_not_at_char_boundary() { + let mut input = ParserInput::new("url(9\nÛ°"); + let mut parser = Parser::new(&mut input); + let result = parser.next_including_whitespace_and_comments(); // This used to panic + assert_eq!(result, Ok(&Token::BadUrl("9\nÛ°".into()))); +} + +#[test] +fn unquoted_url_escaping() { + let token = Token::UnquotedUrl( + "\ + \x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\ + \x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f \ + !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]\ + ^_`abcdefghijklmnopqrstuvwxyz{|}~\x7fé\ + " + .into(), + ); + let serialized = token.to_css_string(); + assert_eq!( + serialized, + "\ + url(\ + \\1 \\2 \\3 \\4 \\5 \\6 \\7 \\8 \\9 \\a \\b \\c \\d \\e \\f \\10 \ + \\11 \\12 \\13 \\14 \\15 \\16 \\17 \\18 \\19 \\1a \\1b \\1c \\1d \\1e \\1f \\20 \ + !\\\"#$%&\\'\\(\\)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]\ + ^_`abcdefghijklmnopqrstuvwxyz{|}~\\7f é\ + )\ + " + ); + let mut input = ParserInput::new(&serialized); + assert_eq!(Parser::new(&mut input).next(), Ok(&token)); +} + +#[test] +fn test_expect_url() { + fn parse<'a>(s: &mut ParserInput<'a>) -> Result<CowRcStr<'a>, BasicParseError<'a>> { + Parser::new(s).expect_url() + } + let mut input = ParserInput::new("url()"); + assert_eq!(parse(&mut input).unwrap(), ""); + let mut input = ParserInput::new("url( "); + assert_eq!(parse(&mut input).unwrap(), ""); + let mut input = ParserInput::new("url( abc"); + assert_eq!(parse(&mut input).unwrap(), "abc"); + let mut input = ParserInput::new("url( abc \t)"); + assert_eq!(parse(&mut input).unwrap(), "abc"); + let mut input = ParserInput::new("url( 'abc' \t)"); + assert_eq!(parse(&mut input).unwrap(), "abc"); + let mut input = ParserInput::new("url(abc more stuff)"); + assert!(parse(&mut input).is_err()); + // The grammar at https://drafts.csswg.org/css-values/#urls plans for `<url-modifier>*` + // at the position of "more stuff", but no such modifier is defined yet. + let mut input = ParserInput::new("url('abc' more stuff)"); + assert!(parse(&mut input).is_err()); +} + +#[test] +fn nth() { + run_json_tests(include_str!("css-parsing-tests/An+B.json"), |input| { + input + .parse_entirely(|i| { + let result: Result<_, ParseError<()>> = parse_nth(i).map_err(Into::into); + result + }) + .ok() + .map(|(v0, v1)| json!([v0, v1])) + .unwrap_or(Value::Null) + }); +} + +#[test] +fn parse_comma_separated_ignoring_errors() { + let input = "red, green something, yellow, whatever, blue"; + let mut input = ParserInput::new(input); + let mut input = Parser::new(&mut input); + let result = input.parse_comma_separated_ignoring_errors(|input| { + let loc = input.current_source_location(); + let ident = input.expect_ident()?; + crate::color::parse_named_color(ident).map_err(|()| { + loc.new_unexpected_token_error::<ParseError<()>>(Token::Ident(ident.clone())) + }) + }); + assert_eq!(result.len(), 3); + assert_eq!(result[0], (255, 0, 0)); + assert_eq!(result[1], (255, 255, 0)); + assert_eq!(result[2], (0, 0, 255)); +} + +#[test] +fn unicode_range() { + run_json_tests(include_str!("css-parsing-tests/urange.json"), |input| { + let result: Result<_, ParseError<()>> = input.parse_comma_separated(|input| { + let result = UnicodeRange::parse(input).ok().map(|r| (r.start, r.end)); + if input.is_exhausted() { + Ok(result) + } else { + while input.next().is_ok() {} + Ok(None) + } + }); + result + .unwrap() + .iter() + .map(|v| { + if let Some((v0, v1)) = v { + json!([v0, v1]) + } else { + Value::Null + } + }) + .collect::<Vec<_>>() + .to_json() + }); +} + +#[test] +fn serializer_not_preserving_comments() { + serializer(false) +} + +#[test] +fn serializer_preserving_comments() { + serializer(true) +} + +fn serializer(preserve_comments: bool) { + run_json_tests( + include_str!("css-parsing-tests/component_value_list.json"), + |input| { + fn write_to( + mut previous_token: TokenSerializationType, + input: &mut Parser, + string: &mut String, + preserve_comments: bool, + ) { + while let Ok(token) = if preserve_comments { + input.next_including_whitespace_and_comments().cloned() + } else { + input.next_including_whitespace().cloned() + } { + let token_type = token.serialization_type(); + if !preserve_comments && previous_token.needs_separator_when_before(token_type) + { + string.push_str("/**/") + } + previous_token = token_type; + token.to_css(string).unwrap(); + let closing_token = match token { + Token::Function(_) | Token::ParenthesisBlock => { + Some(Token::CloseParenthesis) + } + Token::SquareBracketBlock => Some(Token::CloseSquareBracket), + Token::CurlyBracketBlock => Some(Token::CloseCurlyBracket), + _ => None, + }; + if let Some(closing_token) = closing_token { + let result: Result<_, ParseError<()>> = input.parse_nested_block(|input| { + write_to(previous_token, input, string, preserve_comments); + Ok(()) + }); + result.unwrap(); + closing_token.to_css(string).unwrap(); + } + } + } + let mut serialized = String::new(); + write_to( + TokenSerializationType::Nothing, + input, + &mut serialized, + preserve_comments, + ); + let mut input = ParserInput::new(&serialized); + let parser = &mut Parser::new(&mut input); + Value::Array(component_values_to_json(parser)) + }, + ); +} + +#[test] +fn serialize_bad_tokens() { + let mut input = ParserInput::new("url(foo\\) b\\)ar)'ba\\'\"z\n4"); + let mut parser = Parser::new(&mut input); + + let token = parser.next().unwrap().clone(); + assert!(matches!(token, Token::BadUrl(_))); + assert_eq!(token.to_css_string(), "url(foo\\) b\\)ar)"); + + let token = parser.next().unwrap().clone(); + assert!(matches!(token, Token::BadString(_))); + assert_eq!(token.to_css_string(), "\"ba'\\\"z"); + + let token = parser.next().unwrap().clone(); + assert!(matches!(token, Token::Number { .. })); + assert_eq!(token.to_css_string(), "4"); + + assert!(parser.next().is_err()); +} + +#[test] +fn line_numbers() { + let mut input = ParserInput::new(concat!( + "fo\\30\r\n", + "0o bar/*\n", + "*/baz\r\n", + "\n", + "url(\r\n", + " u \r\n", + ")\"a\\\r\n", + "b\"" + )); + let mut input = Parser::new(&mut input); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 0, column: 1 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("fo00o".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 3 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::WhiteSpace(" ")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 4 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("bar".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 1, column: 7 } + ); + assert_eq!( + input.next_including_whitespace_and_comments(), + Ok(&Token::Comment("\n")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 2, column: 3 } + ); + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::Ident("baz".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 2, column: 6 } + ); + let state = input.state(); + + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::WhiteSpace("\r\n\n")) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 4, column: 1 } + ); + + assert_eq!( + state.source_location(), + SourceLocation { line: 2, column: 6 } + ); + + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::UnquotedUrl("u".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 6, column: 2 } + ); + + assert_eq!( + input.next_including_whitespace(), + Ok(&Token::QuotedString("ab".into())) + ); + assert_eq!( + input.current_source_location(), + SourceLocation { line: 7, column: 3 } + ); + assert!(input.next_including_whitespace().is_err()); +} + +#[test] +fn overflow() { + let css = r" + 2147483646 + 2147483647 + 2147483648 + 10000000000000 + 1000000000000000000000000000000000000000 + 1{309 zeros} + + -2147483647 + -2147483648 + -2147483649 + -10000000000000 + -1000000000000000000000000000000000000000 + -1{309 zeros} + + 3.30282347e+38 + 3.40282347e+38 + 3.402824e+38 + + -3.30282347e+38 + -3.40282347e+38 + -3.402824e+38 + + " + .replace("{309 zeros}", &"0".repeat(309)); + let mut input = ParserInput::new(&css); + let mut input = Parser::new(&mut input); + + assert_eq!(input.expect_integer(), Ok(2147483646)); + assert_eq!(input.expect_integer(), Ok(2147483647)); + assert_eq!(input.expect_integer(), Ok(2147483647)); // Clamp on overflow + assert_eq!(input.expect_integer(), Ok(2147483647)); + assert_eq!(input.expect_integer(), Ok(2147483647)); + assert_eq!(input.expect_integer(), Ok(2147483647)); + + assert_eq!(input.expect_integer(), Ok(-2147483647)); + assert_eq!(input.expect_integer(), Ok(-2147483648)); + assert_eq!(input.expect_integer(), Ok(-2147483648)); // Clamp on overflow + assert_eq!(input.expect_integer(), Ok(-2147483648)); + assert_eq!(input.expect_integer(), Ok(-2147483648)); + assert_eq!(input.expect_integer(), Ok(-2147483648)); + + assert_eq!(input.expect_number(), Ok(3.302_823_5e38)); + assert_eq!(input.expect_number(), Ok(f32::MAX)); + assert_eq!(input.expect_number(), Ok(f32::INFINITY)); + + assert_eq!(input.expect_number(), Ok(-3.302_823_5e38)); + assert_eq!(input.expect_number(), Ok(f32::MIN)); + assert_eq!(input.expect_number(), Ok(f32::NEG_INFINITY)); +} + +#[test] +fn line_delimited() { + let mut input = ParserInput::new(" { foo ; bar } baz;,"); + let mut input = Parser::new(&mut input); + assert_eq!(input.next(), Ok(&Token::CurlyBracketBlock)); + assert!({ + let result: Result<_, ParseError<()>> = + input.parse_until_after(Delimiter::Semicolon, |_| Ok(42)); + result + } + .is_err()); + assert_eq!(input.next(), Ok(&Token::Comma)); + assert!(input.next().is_err()); +} + +#[test] +fn identifier_serialization() { + // Null bytes + assert_eq!(Token::Ident("\0".into()).to_css_string(), "\u{FFFD}"); + assert_eq!(Token::Ident("a\0".into()).to_css_string(), "a\u{FFFD}"); + assert_eq!(Token::Ident("\0b".into()).to_css_string(), "\u{FFFD}b"); + assert_eq!(Token::Ident("a\0b".into()).to_css_string(), "a\u{FFFD}b"); + + // Replacement character + assert_eq!(Token::Ident("\u{FFFD}".into()).to_css_string(), "\u{FFFD}"); + assert_eq!( + Token::Ident("a\u{FFFD}".into()).to_css_string(), + "a\u{FFFD}" + ); + assert_eq!( + Token::Ident("\u{FFFD}b".into()).to_css_string(), + "\u{FFFD}b" + ); + assert_eq!( + Token::Ident("a\u{FFFD}b".into()).to_css_string(), + "a\u{FFFD}b" + ); + + // Number prefix + assert_eq!(Token::Ident("0a".into()).to_css_string(), "\\30 a"); + assert_eq!(Token::Ident("1a".into()).to_css_string(), "\\31 a"); + assert_eq!(Token::Ident("2a".into()).to_css_string(), "\\32 a"); + assert_eq!(Token::Ident("3a".into()).to_css_string(), "\\33 a"); + assert_eq!(Token::Ident("4a".into()).to_css_string(), "\\34 a"); + assert_eq!(Token::Ident("5a".into()).to_css_string(), "\\35 a"); + assert_eq!(Token::Ident("6a".into()).to_css_string(), "\\36 a"); + assert_eq!(Token::Ident("7a".into()).to_css_string(), "\\37 a"); + assert_eq!(Token::Ident("8a".into()).to_css_string(), "\\38 a"); + assert_eq!(Token::Ident("9a".into()).to_css_string(), "\\39 a"); + + // Letter number prefix + assert_eq!(Token::Ident("a0b".into()).to_css_string(), "a0b"); + assert_eq!(Token::Ident("a1b".into()).to_css_string(), "a1b"); + assert_eq!(Token::Ident("a2b".into()).to_css_string(), "a2b"); + assert_eq!(Token::Ident("a3b".into()).to_css_string(), "a3b"); + assert_eq!(Token::Ident("a4b".into()).to_css_string(), "a4b"); + assert_eq!(Token::Ident("a5b".into()).to_css_string(), "a5b"); + assert_eq!(Token::Ident("a6b".into()).to_css_string(), "a6b"); + assert_eq!(Token::Ident("a7b".into()).to_css_string(), "a7b"); + assert_eq!(Token::Ident("a8b".into()).to_css_string(), "a8b"); + assert_eq!(Token::Ident("a9b".into()).to_css_string(), "a9b"); + + // Dash number prefix + assert_eq!(Token::Ident("-0a".into()).to_css_string(), "-\\30 a"); + assert_eq!(Token::Ident("-1a".into()).to_css_string(), "-\\31 a"); + assert_eq!(Token::Ident("-2a".into()).to_css_string(), "-\\32 a"); + assert_eq!(Token::Ident("-3a".into()).to_css_string(), "-\\33 a"); + assert_eq!(Token::Ident("-4a".into()).to_css_string(), "-\\34 a"); + assert_eq!(Token::Ident("-5a".into()).to_css_string(), "-\\35 a"); + assert_eq!(Token::Ident("-6a".into()).to_css_string(), "-\\36 a"); + assert_eq!(Token::Ident("-7a".into()).to_css_string(), "-\\37 a"); + assert_eq!(Token::Ident("-8a".into()).to_css_string(), "-\\38 a"); + assert_eq!(Token::Ident("-9a".into()).to_css_string(), "-\\39 a"); + + // Double dash prefix + assert_eq!(Token::Ident("--a".into()).to_css_string(), "--a"); + + // Various tests + assert_eq!( + Token::Ident("\x01\x02\x1E\x1F".into()).to_css_string(), + "\\1 \\2 \\1e \\1f " + ); + assert_eq!( + Token::Ident("\u{0080}\x2D\x5F\u{00A9}".into()).to_css_string(), + "\u{0080}\x2D\x5F\u{00A9}" + ); + assert_eq!(Token::Ident("\x7F\u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\ + \u{008A}\u{008B}\u{008C}\u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\ + \u{0097}\u{0098}\u{0099}\u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}".into()).to_css_string(), + "\\7f \u{0080}\u{0081}\u{0082}\u{0083}\u{0084}\u{0085}\u{0086}\u{0087}\u{0088}\u{0089}\u{008A}\u{008B}\u{008C}\ + \u{008D}\u{008E}\u{008F}\u{0090}\u{0091}\u{0092}\u{0093}\u{0094}\u{0095}\u{0096}\u{0097}\u{0098}\u{0099}\ + \u{009A}\u{009B}\u{009C}\u{009D}\u{009E}\u{009F}"); + assert_eq!( + Token::Ident("\u{00A0}\u{00A1}\u{00A2}".into()).to_css_string(), + "\u{00A0}\u{00A1}\u{00A2}" + ); + assert_eq!( + Token::Ident("a0123456789b".into()).to_css_string(), + "a0123456789b" + ); + assert_eq!( + Token::Ident("abcdefghijklmnopqrstuvwxyz".into()).to_css_string(), + "abcdefghijklmnopqrstuvwxyz" + ); + assert_eq!( + Token::Ident("ABCDEFGHIJKLMNOPQRSTUVWXYZ".into()).to_css_string(), + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + ); + assert_eq!( + Token::Ident("\x20\x21\x78\x79".into()).to_css_string(), + "\\ \\!xy" + ); + + // astral symbol (U+1D306 TETRAGRAM FOR CENTRE) + assert_eq!( + Token::Ident("\u{1D306}".into()).to_css_string(), + "\u{1D306}" + ); +} + +trait ToJson { + fn to_json(&self) -> Value; +} + +impl<T> ToJson for T +where + T: Clone, + Value: From<T>, +{ + fn to_json(&self) -> Value { + Value::from(self.clone()) + } +} + +impl ToJson for CowRcStr<'_> { + fn to_json(&self) -> Value { + let s: &str = self; + s.to_json() + } +} + +#[bench] +#[cfg(feature = "bench")] +fn delimiter_from_byte(b: &mut Bencher) { + use crate::Delimiters; + b.iter(|| { + for _ in 0..1000 { + for i in 0..256 { + std::hint::black_box(Delimiters::from_byte(Some(i as u8))); + } + } + }) +} + +#[cfg(feature = "bench")] +const BACKGROUND_IMAGE: &'static str = include_str!("big-data-url.css"); + +#[cfg(feature = "bench")] +#[bench] +fn unquoted_url(b: &mut Bencher) { + b.iter(|| { + let mut input = ParserInput::new(BACKGROUND_IMAGE); + let mut input = Parser::new(&mut input); + input.look_for_var_or_env_functions(); + + let result = input.try_parse(|input| input.expect_url()); + + assert!(result.is_ok()); + + input.seen_var_or_env_functions(); + (result.is_ok(), input.seen_var_or_env_functions()) + }) +} + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[cfg(feature = "bench")] +#[bench] +fn numeric(b: &mut Bencher) { + b.iter(|| { + for _ in 0..1000000 { + let mut input = ParserInput::new("10px"); + let mut input = Parser::new(&mut input); + let _ = test::black_box(input.next()); + } + }) +} + +struct JsonParser; + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[test] +fn no_stack_overflow_multiple_nested_blocks() { + let mut input: String = "{{".into(); + for _ in 0..20 { + let dup = input.clone(); + input.push_str(&dup); + } + let mut input = ParserInput::new(&input); + let mut input = Parser::new(&mut input); + while input.next().is_ok() {} +} + +impl<'i> DeclarationParser<'i> for JsonParser { + type Declaration = Value; + type Error = (); + + fn parse_value<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + _declaration_start: &ParserState, + ) -> Result<Value, ParseError<'i, ()>> { + let mut value = vec![]; + let mut important = false; + loop { + let start = input.state(); + if let Ok(mut token) = input.next_including_whitespace().cloned() { + // Hack to deal with css-parsing-tests assuming that + // `!important` in the middle of a declaration value is OK. + // This can never happen per spec + // (even CSS Variables forbid top-level `!`) + if token == Token::Delim('!') { + input.reset(&start); + if parse_important(input).is_ok() && input.is_exhausted() { + important = true; + break; + } + input.reset(&start); + token = input.next_including_whitespace().unwrap().clone(); + } + value.push(one_component_value_to_json(token, input)); + } else { + break; + } + } + Ok(JArray!["declaration", name, value, important,]) + } +} + +impl<'i> AtRuleParser<'i> for JsonParser { + type Prelude = Vec<Value>; + type AtRule = Value; + type Error = (); + + fn parse_prelude<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<Vec<Value>, ParseError<'i, ()>> { + let prelude = vec![ + "at-rule".to_json(), + name.to_json(), + Value::Array(component_values_to_json(input)), + ]; + match_ignore_ascii_case! { &*name, + "charset" => { + Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone()))) + }, + _ => Ok(prelude), + } + } + + fn rule_without_block( + &mut self, + mut prelude: Vec<Value>, + _: &ParserState, + ) -> Result<Value, ()> { + prelude.push(Value::Null); + Ok(Value::Array(prelude)) + } + + fn parse_block<'t>( + &mut self, + mut prelude: Vec<Value>, + _: &ParserState, + input: &mut Parser<'i, 't>, + ) -> Result<Value, ParseError<'i, ()>> { + prelude.push(Value::Array(component_values_to_json(input))); + Ok(Value::Array(prelude)) + } +} + +impl<'i> QualifiedRuleParser<'i> for JsonParser { + type Prelude = Vec<Value>; + type QualifiedRule = Value; + type Error = (); + + fn parse_prelude<'t>( + &mut self, + input: &mut Parser<'i, 't>, + ) -> Result<Vec<Value>, ParseError<'i, ()>> { + Ok(component_values_to_json(input)) + } + + fn parse_block<'t>( + &mut self, + prelude: Vec<Value>, + _: &ParserState, + input: &mut Parser<'i, 't>, + ) -> Result<Value, ParseError<'i, ()>> { + Ok(JArray![ + "qualified rule", + prelude, + component_values_to_json(input), + ]) + } +} + +impl RuleBodyItemParser<'_, Value, ()> for JsonParser { + fn parse_qualified(&self) -> bool { + true + } + fn parse_declarations(&self) -> bool { + true + } +} + +fn component_values_to_json(input: &mut Parser) -> Vec<Value> { + let mut values = vec![]; + while let Ok(token) = input.next_including_whitespace().cloned() { + values.push(one_component_value_to_json(token, input)); + } + values +} + +fn one_component_value_to_json(token: Token, input: &mut Parser) -> Value { + fn numeric(value: f32, int_value: Option<i32>, has_sign: bool) -> Vec<Value> { + vec![ + Token::Number { + value, + int_value, + has_sign, + } + .to_css_string() + .to_json(), + match int_value { + Some(i) => i.to_json(), + None => value.to_json(), + }, + match int_value { + Some(_) => "integer", + None => "number", + } + .to_json(), + ] + } + + fn nested(input: &mut Parser) -> Vec<Value> { + let result: Result<_, ParseError<()>> = + input.parse_nested_block(|input| Ok(component_values_to_json(input))); + result.unwrap() + } + + match token { + Token::Ident(value) => JArray!["ident", value], + Token::AtKeyword(value) => JArray!["at-keyword", value], + Token::Hash(value) => JArray!["hash", value, "unrestricted"], + Token::IDHash(value) => JArray!["hash", value, "id"], + Token::QuotedString(value) => JArray!["string", value], + Token::UnquotedUrl(value) => JArray!["url", value], + Token::Delim('\\') => "\\".to_json(), + Token::Delim(value) => value.to_string().to_json(), + + Token::Number { + value, + int_value, + has_sign, + } => Value::Array({ + let mut v = vec!["number".to_json()]; + v.extend(numeric(value, int_value, has_sign)); + v + }), + Token::Percentage { + unit_value, + int_value, + has_sign, + } => Value::Array({ + let mut v = vec!["percentage".to_json()]; + v.extend(numeric(unit_value * 100., int_value, has_sign)); + v + }), + Token::Dimension { + value, + int_value, + has_sign, + unit, + } => Value::Array({ + let mut v = vec!["dimension".to_json()]; + v.extend(numeric(value, int_value, has_sign)); + v.push(unit.to_json()); + v + }), + + Token::WhiteSpace(_) => " ".to_json(), + Token::Comment(_) => "/**/".to_json(), + Token::Colon => ":".to_json(), + Token::Semicolon => ";".to_json(), + Token::Comma => ",".to_json(), + Token::IncludeMatch => "~=".to_json(), + Token::DashMatch => "|=".to_json(), + Token::PrefixMatch => "^=".to_json(), + Token::SuffixMatch => "$=".to_json(), + Token::SubstringMatch => "*=".to_json(), + Token::CDO => "<!--".to_json(), + Token::CDC => "-->".to_json(), + + Token::Function(name) => Value::Array({ + let mut v = vec!["function".to_json(), name.to_json()]; + v.extend(nested(input)); + v + }), + Token::ParenthesisBlock => Value::Array({ + let mut v = vec!["()".to_json()]; + v.extend(nested(input)); + v + }), + Token::SquareBracketBlock => Value::Array({ + let mut v = vec!["[]".to_json()]; + v.extend(nested(input)); + v + }), + Token::CurlyBracketBlock => Value::Array({ + let mut v = vec!["{}".to_json()]; + v.extend(nested(input)); + v + }), + Token::BadUrl(_) => JArray!["error", "bad-url"], + Token::BadString(_) => JArray!["error", "bad-string"], + Token::CloseParenthesis => JArray!["error", ")"], + Token::CloseSquareBracket => JArray!["error", "]"], + Token::CloseCurlyBracket => JArray!["error", "}"], + } +} + +/// A previous version of procedural-masquerade had a bug where it +/// would normalize consecutive whitespace to a single space, +/// including in string literals. +#[test] +fn procedural_masquerade_whitespace() { + ascii_case_insensitive_phf_map! { + map -> () = { + " \t\n" => () + } + } + assert_eq!(map::get(" \t\n"), Some(&())); + assert_eq!(map::get(" "), None); + + match_ignore_ascii_case! { " \t\n", + " " => panic!("1"), + " \t\n" => {}, + _ => panic!("2"), + } + + match_ignore_ascii_case! { " ", + " \t\n" => panic!("3"), + " " => {}, + _ => panic!("4"), + } +} + +#[test] +fn parse_until_before_stops_at_delimiter_or_end_of_input() { + // For all j and k, inputs[i].1[j] should parse the same as inputs[i].1[k] + // when we use delimiters inputs[i].0. + let inputs = vec![ + ( + Delimiter::Bang | Delimiter::Semicolon, + // Note that the ';extra' is fine, because the ';' acts the same as + // the end of input. + vec!["token stream;extra", "token stream!", "token stream"], + ), + (Delimiter::Bang | Delimiter::Semicolon, vec![";", "!", ""]), + ]; + for equivalent in inputs { + for (j, x) in equivalent.1.iter().enumerate() { + for y in equivalent.1[j + 1..].iter() { + let mut ix = ParserInput::new(x); + let mut ix = Parser::new(&mut ix); + + let mut iy = ParserInput::new(y); + let mut iy = Parser::new(&mut iy); + + let _ = ix.parse_until_before::<_, _, ()>(equivalent.0, |ix| { + iy.parse_until_before::<_, _, ()>(equivalent.0, |iy| { + loop { + let ox = ix.next(); + let oy = iy.next(); + assert_eq!(ox, oy); + if ox.is_err() { + break; + } + } + Ok(()) + }) + }); + } + } + } +} + +#[test] +fn parser_maintains_current_line() { + let mut input = ParserInput::new("ident ident;\nident ident ident;\nident"); + let mut parser = Parser::new(&mut input); + assert_eq!(parser.current_line(), "ident ident;"); + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.next(), Ok(&Token::Semicolon)); + + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.current_line(), "ident ident ident;"); + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.next(), Ok(&Token::Semicolon)); + + assert_eq!(parser.next(), Ok(&Token::Ident("ident".into()))); + assert_eq!(parser.current_line(), "ident"); +} + +#[test] +fn cdc_regression_test() { + let mut input = ParserInput::new("-->x"); + let mut parser = Parser::new(&mut input); + parser.skip_cdc_and_cdo(); + assert_eq!(parser.next(), Ok(&Token::Ident("x".into()))); + assert_eq!( + parser.next(), + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + location: SourceLocation { line: 0, column: 5 } + }) + ); +} + +#[test] +fn parse_entirely_reports_first_error() { + #[derive(PartialEq, Debug)] + enum E { + Foo, + } + let mut input = ParserInput::new("ident"); + let mut parser = Parser::new(&mut input); + let result: Result<(), _> = parser.parse_entirely(|p| Err(p.new_custom_error(E::Foo))); + assert_eq!( + result, + Err(ParseError { + kind: ParseErrorKind::Custom(E::Foo), + location: SourceLocation { line: 0, column: 1 }, + }) + ); +} + +#[test] +fn parse_sourcemapping_comments() { + let tests = vec![ + ("/*# sourceMappingURL=here*/", Some("here")), + ("/*# sourceMappingURL=here */", Some("here")), + ("/*@ sourceMappingURL=here*/", Some("here")), + ( + "/*@ sourceMappingURL=there*/ /*# sourceMappingURL=here*/", + Some("here"), + ), + ("/*# sourceMappingURL=here there */", Some("here")), + ("/*# sourceMappingURL= here */", Some("")), + ("/*# sourceMappingURL=*/", Some("")), + ("/*# sourceMappingUR=here */", None), + ("/*! sourceMappingURL=here */", None), + ("/*# sourceMappingURL = here */", None), + ("/* # sourceMappingURL=here */", None), + ]; + + for test in tests { + let mut input = ParserInput::new(test.0); + let mut parser = Parser::new(&mut input); + while parser.next_including_whitespace().is_ok() {} + assert_eq!(parser.current_source_map_url(), test.1); + } +} + +#[test] +fn parse_sourceurl_comments() { + let tests = vec![ + ("/*# sourceURL=here*/", Some("here")), + ("/*# sourceURL=here */", Some("here")), + ("/*@ sourceURL=here*/", Some("here")), + ("/*@ sourceURL=there*/ /*# sourceURL=here*/", Some("here")), + ("/*# sourceURL=here there */", Some("here")), + ("/*# sourceURL= here */", Some("")), + ("/*# sourceURL=*/", Some("")), + ("/*# sourceMappingUR=here */", None), + ("/*! sourceURL=here */", None), + ("/*# sourceURL = here */", None), + ("/* # sourceURL=here */", None), + ]; + + for test in tests { + let mut input = ParserInput::new(test.0); + let mut parser = Parser::new(&mut input); + while parser.next_including_whitespace().is_ok() {} + assert_eq!(parser.current_source_url(), test.1); + } +} + +#[cfg_attr(all(miri, feature = "skip_long_tests"), ignore)] +#[test] +fn roundtrip_percentage_token() { + fn test_roundtrip(value: &str) { + let mut input = ParserInput::new(value); + let mut parser = Parser::new(&mut input); + let token = parser.next().unwrap(); + assert_eq!(token.to_css_string(), value); + } + // Test simple number serialization + for i in 0..101 { + test_roundtrip(&format!("{}%", i)); + for j in 0..10 { + if j != 0 { + test_roundtrip(&format!("{}.{}%", i, j)); + } + for k in 1..10 { + test_roundtrip(&format!("{}.{}{}%", i, j, k)); + } + } + } +} + +#[test] +fn utf16_columns() { + // This particular test serves two purposes. First, it checks + // that the column number computations are correct. Second, it + // checks that tokenizer code paths correctly differentiate + // between the different UTF-8 encoding bytes. In particular + // different leader bytes and continuation bytes are treated + // differently, so we make sure to include all lengths in the + // tests, using the string "QΡ✈🆒". Also, remember that because + // the column is in units of UTF-16, the 4-byte sequence results + // in two columns. + let tests = vec![ + ("", 1), + ("ascii", 6), + ("/*QΡ✈🆒*/", 10), + ("'QΡ✈🆒*'", 9), + ("\"\\\"'QΡ✈🆒*'", 12), + ("\\Q\\Ρ\\✈\\🆒", 10), + ("QΡ✈🆒", 6), + ("QΡ✈🆒\\Q\\Ρ\\✈\\🆒", 15), + ("newline\r\nQΡ✈🆒", 6), + ("url(QΡ✈🆒\\Q\\Ρ\\✈\\🆒)", 20), + ("url(QΡ✈🆒)", 11), + ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒)", 16), + ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒", 15), + ("url(\r\nQΡ✈🆒\\Q\\Ρ\\✈\\🆒 x", 17), + ("QΡ✈🆒()", 8), + // Test that under/over-flow of current_line_start_position is + // handled properly; see the special case in consume_4byte_intro. + ("🆒", 3), + ]; + + for test in tests { + let mut input = ParserInput::new(test.0); + let mut parser = Parser::new(&mut input); + + // Read all tokens. + loop { + match parser.next() { + Err(BasicParseError { + kind: BasicParseErrorKind::EndOfInput, + .. + }) => { + break; + } + Err(_) => { + // should this be an explicit panic instead? + unreachable!(); + } + Ok(_) => {} + }; + } + + // Check the resulting column. + assert_eq!(parser.current_source_location().column, test.1); + } +} + +#[test] +fn servo_define_css_keyword_enum() { + macro_rules! define_css_keyword_enum { + (pub enum $name:ident { $($variant:ident = $css:pat,)+ }) => { + #[derive(PartialEq, Debug)] + pub enum $name { + $($variant),+ + } + + impl $name { + pub fn from_ident(ident: &str) -> Result<$name, ()> { + match_ignore_ascii_case! { ident, + $($css => Ok($name::$variant),)+ + _ => Err(()) + } + } + } + } + } + define_css_keyword_enum! { + pub enum UserZoom { + Zoom = "zoom", + Fixed = "fixed", + } + } + + assert_eq!(UserZoom::from_ident("fixed"), Ok(UserZoom::Fixed)); +}
diff --git a/src/tokenizer.rs b/src/tokenizer.rs new file mode 100644 index 0000000..1c85e10 --- /dev/null +++ b/src/tokenizer.rs
@@ -0,0 +1,1409 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// https://drafts.csswg.org/css-syntax/#tokenization + +use self::Token::*; +use crate::cow_rc_str::CowRcStr; +use crate::parser::ParserState; +use std::char; +use std::ops::Range; + +#[cfg(not(feature = "dummy_match_byte"))] +use cssparser_macros::match_byte; + +#[cfg(feature = "dummy_match_byte")] +macro_rules! match_byte { + ($value:expr, $($rest:tt)* ) => { + match $value { + $( + $rest + )+ + } + }; +} + +/// One of the pieces the CSS input is broken into. +/// +/// Some components use `Cow` in order to borrow from the original input string +/// and avoid allocating/copying when possible. +#[derive(PartialEq, Debug, Clone)] +pub enum Token<'a> { + /// A [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram) + Ident(CowRcStr<'a>), + + /// A [`<at-keyword-token>`](https://drafts.csswg.org/css-syntax/#at-keyword-token-diagram) + /// + /// The value does not include the `@` marker. + AtKeyword(CowRcStr<'a>), + + /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "unrestricted" + /// + /// The value does not include the `#` marker. + Hash(CowRcStr<'a>), + + /// A [`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type flag set to "id" + /// + /// The value does not include the `#` marker. + IDHash(CowRcStr<'a>), // Hash that is a valid ID selector. + + /// A [`<string-token>`](https://drafts.csswg.org/css-syntax/#string-token-diagram) + /// + /// The value does not include the quotes. + QuotedString(CowRcStr<'a>), + + /// A [`<url-token>`](https://drafts.csswg.org/css-syntax/#url-token-diagram) + /// + /// The value does not include the `url(` `)` markers. Note that `url( <string-token> )` is represented by a + /// `Function` token. + UnquotedUrl(CowRcStr<'a>), + + /// A `<delim-token>` + Delim(char), + + /// A [`<number-token>`](https://drafts.csswg.org/css-syntax/#number-token-diagram) + Number { + /// Whether the number had a `+` or `-` sign. + /// + /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.) + has_sign: bool, + + /// The value as a float + value: f32, + + /// If the origin source did not include a fractional part, the value as an integer. + int_value: Option<i32>, + }, + + /// A [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram) + Percentage { + /// Whether the number had a `+` or `-` sign. + has_sign: bool, + + /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0. + unit_value: f32, + + /// If the origin source did not include a fractional part, the value as an integer. + /// It is **not** divided by 100. + int_value: Option<i32>, + }, + + /// A [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram) + Dimension { + /// Whether the number had a `+` or `-` sign. + /// + /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.) + has_sign: bool, + + /// The value as a float + value: f32, + + /// If the origin source did not include a fractional part, the value as an integer. + int_value: Option<i32>, + + /// The unit, e.g. "px" in `12px` + unit: CowRcStr<'a>, + }, + + /// A [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram) + WhiteSpace(&'a str), + + /// A comment. + /// + /// The CSS Syntax spec does not generate tokens for comments, + /// But we do, because we can (borrowed &str makes it cheap). + /// + /// The value does not include the `/*` `*/` markers. + Comment(&'a str), + + /// A `:` `<colon-token>` + Colon, // : + + /// A `;` `<semicolon-token>` + Semicolon, // ; + + /// A `,` `<comma-token>` + Comma, // , + + /// A `~=` [`<include-match-token>`](https://drafts.csswg.org/css-syntax/#include-match-token-diagram) + IncludeMatch, + + /// A `|=` [`<dash-match-token>`](https://drafts.csswg.org/css-syntax/#dash-match-token-diagram) + DashMatch, + + /// A `^=` [`<prefix-match-token>`](https://drafts.csswg.org/css-syntax/#prefix-match-token-diagram) + PrefixMatch, + + /// A `$=` [`<suffix-match-token>`](https://drafts.csswg.org/css-syntax/#suffix-match-token-diagram) + SuffixMatch, + + /// A `*=` [`<substring-match-token>`](https://drafts.csswg.org/css-syntax/#substring-match-token-diagram) + SubstringMatch, + + /// A `<!--` [`<CDO-token>`](https://drafts.csswg.org/css-syntax/#CDO-token-diagram) + CDO, + + /// A `-->` [`<CDC-token>`](https://drafts.csswg.org/css-syntax/#CDC-token-diagram) + CDC, + + /// A [`<function-token>`](https://drafts.csswg.org/css-syntax/#function-token-diagram) + /// + /// The value (name) does not include the `(` marker. + Function(CowRcStr<'a>), + + /// A `<(-token>` + ParenthesisBlock, + + /// A `<[-token>` + SquareBracketBlock, + + /// A `<{-token>` + CurlyBracketBlock, + + /// A `<bad-url-token>` + /// + /// This token always indicates a parse error. + BadUrl(CowRcStr<'a>), + + /// A `<bad-string-token>` + /// + /// This token always indicates a parse error. + BadString(CowRcStr<'a>), + + /// A `<)-token>` + /// + /// When obtained from one of the `Parser::next*` methods, + /// this token is always unmatched and indicates a parse error. + CloseParenthesis, + + /// A `<]-token>` + /// + /// When obtained from one of the `Parser::next*` methods, + /// this token is always unmatched and indicates a parse error. + CloseSquareBracket, + + /// A `<}-token>` + /// + /// When obtained from one of the `Parser::next*` methods, + /// this token is always unmatched and indicates a parse error. + CloseCurlyBracket, +} + +impl Token<'_> { + /// Return whether this token represents a parse error. + /// + /// `BadUrl` and `BadString` are tokenizer-level parse errors. + /// + /// `CloseParenthesis`, `CloseSquareBracket`, and `CloseCurlyBracket` are *unmatched* + /// and therefore parse errors when returned by one of the `Parser::next*` methods. + pub fn is_parse_error(&self) -> bool { + matches!( + *self, + BadUrl(_) | BadString(_) | CloseParenthesis | CloseSquareBracket | CloseCurlyBracket + ) + } +} + +#[derive(Clone)] +pub struct Tokenizer<'a> { + input: &'a str, + /// Counted in bytes, not code points. From 0. + position: usize, + /// The position at the start of the current line; but adjusted to + /// ensure that computing the column will give the result in units + /// of UTF-16 characters. + current_line_start_position: usize, + current_line_number: u32, + var_or_env_functions: SeenStatus, + source_map_url: Option<&'a str>, + source_url: Option<&'a str>, +} + +#[derive(Copy, Clone, PartialEq, Eq)] +enum SeenStatus { + DontCare, + LookingForThem, + SeenAtLeastOne, +} + +impl<'a> Tokenizer<'a> { + #[inline] + pub fn new(input: &str) -> Tokenizer { + Tokenizer { + input, + position: 0, + current_line_start_position: 0, + current_line_number: 0, + var_or_env_functions: SeenStatus::DontCare, + source_map_url: None, + source_url: None, + } + } + + #[inline] + pub fn look_for_var_or_env_functions(&mut self) { + self.var_or_env_functions = SeenStatus::LookingForThem; + } + + #[inline] + pub fn seen_var_or_env_functions(&mut self) -> bool { + let seen = self.var_or_env_functions == SeenStatus::SeenAtLeastOne; + self.var_or_env_functions = SeenStatus::DontCare; + seen + } + + #[inline] + pub fn see_function(&mut self, name: &str) { + if self.var_or_env_functions == SeenStatus::LookingForThem + && (name.eq_ignore_ascii_case("var") || name.eq_ignore_ascii_case("env")) + { + self.var_or_env_functions = SeenStatus::SeenAtLeastOne; + } + } + + #[inline] + pub fn next(&mut self) -> Result<Token<'a>, ()> { + next_token(self) + } + + #[inline] + pub fn position(&self) -> SourcePosition { + debug_assert!(self.input.is_char_boundary(self.position)); + SourcePosition(self.position) + } + + #[inline] + pub fn current_source_location(&self) -> SourceLocation { + SourceLocation { + line: self.current_line_number, + column: (self.position - self.current_line_start_position + 1) as u32, + } + } + + #[inline] + pub fn current_source_map_url(&self) -> Option<&'a str> { + self.source_map_url + } + + #[inline] + pub fn current_source_url(&self) -> Option<&'a str> { + self.source_url + } + + #[inline] + pub fn state(&self) -> ParserState { + ParserState { + position: self.position, + current_line_start_position: self.current_line_start_position, + current_line_number: self.current_line_number, + at_start_of: None, + } + } + + #[inline] + pub fn reset(&mut self, state: &ParserState) { + self.position = state.position; + self.current_line_start_position = state.current_line_start_position; + self.current_line_number = state.current_line_number; + } + + #[inline] + pub(crate) fn slice_from(&self, start_pos: SourcePosition) -> &'a str { + self.slice(start_pos..self.position()) + } + + #[inline] + pub(crate) fn slice(&self, range: Range<SourcePosition>) -> &'a str { + debug_assert!(self.input.is_char_boundary(range.start.0)); + debug_assert!(self.input.is_char_boundary(range.end.0)); + unsafe { self.input.get_unchecked(range.start.0..range.end.0) } + } + + pub fn current_source_line(&self) -> &'a str { + let current = self.position(); + let start = self + .slice(SourcePosition(0)..current) + .rfind(['\r', '\n', '\x0C']) + .map_or(0, |start| start + 1); + let end = self + .slice(current..SourcePosition(self.input.len())) + .find(['\r', '\n', '\x0C']) + .map_or(self.input.len(), |end| current.0 + end); + self.slice(SourcePosition(start)..SourcePosition(end)) + } + + #[inline] + pub fn next_byte(&self) -> Option<u8> { + if self.is_eof() { + None + } else { + Some(self.input.as_bytes()[self.position]) + } + } + + // If false, `tokenizer.next_char()` will not panic. + #[inline] + fn is_eof(&self) -> bool { + !self.has_at_least(0) + } + + // If true, the input has at least `n` bytes left *after* the current one. + // That is, `tokenizer.char_at(n)` will not panic. + #[inline] + fn has_at_least(&self, n: usize) -> bool { + self.position + n < self.input.len() + } + + // Advance over N bytes in the input. This function can advance + // over ASCII bytes (excluding newlines), or UTF-8 sequence + // leaders (excluding leaders for 4-byte sequences). + #[inline] + pub fn advance(&mut self, n: usize) { + if cfg!(debug_assertions) { + // Each byte must either be an ASCII byte or a sequence + // leader, but not a 4-byte leader; also newlines are + // rejected. + for i in 0..n { + let b = self.byte_at(i); + debug_assert!(b.is_ascii() || (b & 0xF0 != 0xF0 && b & 0xC0 != 0x80)); + debug_assert!(b != b'\r' && b != b'\n' && b != b'\x0C'); + } + } + self.position += n + } + + // Assumes non-EOF + #[inline] + fn next_byte_unchecked(&self) -> u8 { + self.byte_at(0) + } + + #[inline] + fn byte_at(&self, offset: usize) -> u8 { + self.input.as_bytes()[self.position + offset] + } + + // Advance over a single byte; the byte must be a UTF-8 sequence + // leader for a 4-byte sequence. + #[inline] + fn consume_4byte_intro(&mut self) { + debug_assert!(self.next_byte_unchecked() & 0xF0 == 0xF0); + // This takes two UTF-16 characters to represent, so we + // actually have an undercount. + self.current_line_start_position = self.current_line_start_position.wrapping_sub(1); + self.position += 1; + } + + // Advance over a single byte; the byte must be a UTF-8 + // continuation byte. + #[inline] + fn consume_continuation_byte(&mut self) { + debug_assert!(self.next_byte_unchecked() & 0xC0 == 0x80); + // Continuation bytes contribute to column overcount. Note + // that due to the special case for the 4-byte sequence intro, + // we must use wrapping add here. + self.current_line_start_position = self.current_line_start_position.wrapping_add(1); + self.position += 1; + } + + // Advance over any kind of byte, excluding newlines. + #[inline(never)] + fn consume_known_byte(&mut self, byte: u8) { + debug_assert!(byte != b'\r' && byte != b'\n' && byte != b'\x0C'); + self.position += 1; + // Continuation bytes contribute to column overcount. + if byte & 0xF0 == 0xF0 { + // This takes two UTF-16 characters to represent, so we + // actually have an undercount. + self.current_line_start_position = self.current_line_start_position.wrapping_sub(1); + } else if byte & 0xC0 == 0x80 { + // Note that due to the special case for the 4-byte + // sequence intro, we must use wrapping add here. + self.current_line_start_position = self.current_line_start_position.wrapping_add(1); + } + } + + #[inline] + fn next_char(&self) -> char { + unsafe { self.input.get_unchecked(self.position().0..) } + .chars() + .next() + .unwrap() + } + + // Given that a newline has been seen, advance over the newline + // and update the state. + #[inline] + fn consume_newline(&mut self) { + let byte = self.next_byte_unchecked(); + debug_assert!(byte == b'\r' || byte == b'\n' || byte == b'\x0C'); + self.position += 1; + if byte == b'\r' && self.next_byte() == Some(b'\n') { + self.position += 1; + } + self.current_line_start_position = self.position; + self.current_line_number += 1; + } + + #[inline] + fn has_newline_at(&self, offset: usize) -> bool { + self.position + offset < self.input.len() + && matches!(self.byte_at(offset), b'\n' | b'\r' | b'\x0C') + } + + #[inline] + fn consume_char(&mut self) -> char { + let c = self.next_char(); + let len_utf8 = c.len_utf8(); + self.position += len_utf8; + // Note that due to the special case for the 4-byte sequence + // intro, we must use wrapping add here. + self.current_line_start_position = self + .current_line_start_position + .wrapping_add(len_utf8 - c.len_utf16()); + c + } + + #[inline] + fn starts_with(&self, needle: &[u8]) -> bool { + self.input.as_bytes()[self.position..].starts_with(needle) + } + + pub fn skip_whitespace(&mut self) { + while !self.is_eof() { + match_byte! { self.next_byte_unchecked(), + b' ' | b'\t' => { + self.advance(1) + }, + b'\n' | b'\x0C' | b'\r' => { + self.consume_newline(); + }, + b'/' => { + if self.starts_with(b"/*") { + consume_comment(self); + } else { + return + } + } + _ => return, + } + } + } + + pub fn skip_cdc_and_cdo(&mut self) { + while !self.is_eof() { + match_byte! { self.next_byte_unchecked(), + b' ' | b'\t' => { + self.advance(1) + }, + b'\n' | b'\x0C' | b'\r' => { + self.consume_newline(); + }, + b'/' => { + if self.starts_with(b"/*") { + consume_comment(self); + } else { + return + } + } + b'<' => { + if self.starts_with(b"<!--") { + self.advance(4) + } else { + return + } + } + b'-' => { + if self.starts_with(b"-->") { + self.advance(3) + } else { + return + } + } + _ => { + return + } + } + } + } +} + +/// A position from the start of the input, counted in UTF-8 bytes. +#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy)] +pub struct SourcePosition(pub(crate) usize); + +#[cfg(feature = "malloc_size_of")] +malloc_size_of::malloc_size_of_is_0!(SourcePosition); + +impl SourcePosition { + /// Returns the current byte index in the original input. + #[inline] + pub fn byte_index(&self) -> usize { + self.0 + } +} + +/// The line and column number for a given position within the input. +#[derive(PartialEq, Eq, Debug, Clone, Copy, Default)] +pub struct SourceLocation { + /// The line number, starting at 0 for the first line. + pub line: u32, + + /// The column number within a line, starting at 1 for first the character of the line. + /// Column numbers are counted in UTF-16 code units. + pub column: u32, +} + +#[cfg(feature = "malloc_size_of")] +malloc_size_of::malloc_size_of_is_0!(SourceLocation); + +fn next_token<'a>(tokenizer: &mut Tokenizer<'a>) -> Result<Token<'a>, ()> { + if tokenizer.is_eof() { + return Err(()); + } + let b = tokenizer.next_byte_unchecked(); + let token = match_byte! { b, + b' ' | b'\t' => { + consume_whitespace(tokenizer, false) + }, + b'\n' | b'\x0C' | b'\r' => consume_whitespace(tokenizer, true), + b'"' => consume_string(tokenizer, false), + b'#' => { + tokenizer.advance(1); + if is_ident_start(tokenizer) { IDHash(consume_name(tokenizer)) } + else if !tokenizer.is_eof() && + matches!(tokenizer.next_byte_unchecked(), b'0'..=b'9' | b'-') { + // Any other valid case here already resulted in IDHash. + Hash(consume_name(tokenizer)) + } + else { Delim('#') } + }, + b'$' => { + if tokenizer.starts_with(b"$=") { tokenizer.advance(2); SuffixMatch } + else { tokenizer.advance(1); Delim('$') } + }, + b'\'' => consume_string(tokenizer, true), + b'(' => { tokenizer.advance(1); ParenthesisBlock }, + b')' => { tokenizer.advance(1); CloseParenthesis }, + b'*' => { + if tokenizer.starts_with(b"*=") { tokenizer.advance(2); SubstringMatch } + else { tokenizer.advance(1); Delim('*') } + }, + b'+' => { + if ( + tokenizer.has_at_least(1) + && tokenizer.byte_at(1).is_ascii_digit() + ) || ( + tokenizer.has_at_least(2) + && tokenizer.byte_at(1) == b'.' + && tokenizer.byte_at(2).is_ascii_digit() + ) { + consume_numeric(tokenizer) + } else { + tokenizer.advance(1); + Delim('+') + } + }, + b',' => { tokenizer.advance(1); Comma }, + b'-' => { + if ( + tokenizer.has_at_least(1) + && tokenizer.byte_at(1).is_ascii_digit() + ) || ( + tokenizer.has_at_least(2) + && tokenizer.byte_at(1) == b'.' + && tokenizer.byte_at(2).is_ascii_digit() + ) { + consume_numeric(tokenizer) + } else if tokenizer.starts_with(b"-->") { + tokenizer.advance(3); + CDC + } else if is_ident_start(tokenizer) { + consume_ident_like(tokenizer) + } else { + tokenizer.advance(1); + Delim('-') + } + }, + b'.' => { + if tokenizer.has_at_least(1) + && tokenizer.byte_at(1).is_ascii_digit() { + consume_numeric(tokenizer) + } else { + tokenizer.advance(1); + Delim('.') + } + } + b'/' => { + if tokenizer.starts_with(b"/*") { + Comment(consume_comment(tokenizer)) + } else { + tokenizer.advance(1); + Delim('/') + } + } + b'0'..=b'9' => consume_numeric(tokenizer), + b':' => { tokenizer.advance(1); Colon }, + b';' => { tokenizer.advance(1); Semicolon }, + b'<' => { + if tokenizer.starts_with(b"<!--") { + tokenizer.advance(4); + CDO + } else { + tokenizer.advance(1); + Delim('<') + } + }, + b'@' => { + tokenizer.advance(1); + if is_ident_start(tokenizer) { AtKeyword(consume_name(tokenizer)) } + else { Delim('@') } + }, + b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'\0' => consume_ident_like(tokenizer), + b'[' => { tokenizer.advance(1); SquareBracketBlock }, + b'\\' => { + if !tokenizer.has_newline_at(1) { consume_ident_like(tokenizer) } + else { tokenizer.advance(1); Delim('\\') } + }, + b']' => { tokenizer.advance(1); CloseSquareBracket }, + b'^' => { + if tokenizer.starts_with(b"^=") { tokenizer.advance(2); PrefixMatch } + else { tokenizer.advance(1); Delim('^') } + }, + b'{' => { tokenizer.advance(1); CurlyBracketBlock }, + b'|' => { + if tokenizer.starts_with(b"|=") { tokenizer.advance(2); DashMatch } + else { tokenizer.advance(1); Delim('|') } + }, + b'}' => { tokenizer.advance(1); CloseCurlyBracket }, + b'~' => { + if tokenizer.starts_with(b"~=") { tokenizer.advance(2); IncludeMatch } + else { tokenizer.advance(1); Delim('~') } + }, + _ => { + if !b.is_ascii() { + consume_ident_like(tokenizer) + } else { + tokenizer.advance(1); + Delim(b as char) + } + }, + }; + Ok(token) +} + +fn consume_whitespace<'a>(tokenizer: &mut Tokenizer<'a>, newline: bool) -> Token<'a> { + let start_position = tokenizer.position(); + if newline { + tokenizer.consume_newline(); + } else { + tokenizer.advance(1); + } + while !tokenizer.is_eof() { + let b = tokenizer.next_byte_unchecked(); + match_byte! { b, + b' ' | b'\t' => { + tokenizer.advance(1); + } + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + _ => { + break + } + } + } + WhiteSpace(tokenizer.slice_from(start_position)) +} + +// Check for sourceMappingURL or sourceURL comments and update the +// tokenizer appropriately. +fn check_for_source_map<'a>(tokenizer: &mut Tokenizer<'a>, contents: &'a str) { + let directive = "# sourceMappingURL="; + let directive_old = "@ sourceMappingURL="; + + // If there is a source map directive, extract the URL. + if contents.starts_with(directive) || contents.starts_with(directive_old) { + let contents = &contents[directive.len()..]; + tokenizer.source_map_url = contents.split([' ', '\t', '\x0C', '\r', '\n']).next(); + } + + let directive = "# sourceURL="; + let directive_old = "@ sourceURL="; + + // If there is a source map directive, extract the URL. + if contents.starts_with(directive) || contents.starts_with(directive_old) { + let contents = &contents[directive.len()..]; + tokenizer.source_url = contents.split([' ', '\t', '\x0C', '\r', '\n']).next() + } +} + +fn consume_comment<'a>(tokenizer: &mut Tokenizer<'a>) -> &'a str { + tokenizer.advance(2); // consume "/*" + let start_position = tokenizer.position(); + while !tokenizer.is_eof() { + match_byte! { tokenizer.next_byte_unchecked(), + b'*' => { + let end_position = tokenizer.position(); + tokenizer.advance(1); + if tokenizer.next_byte() == Some(b'/') { + tokenizer.advance(1); + let contents = tokenizer.slice(start_position..end_position); + check_for_source_map(tokenizer, contents); + return contents + } + } + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); } + b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); } + _ => { + // ASCII or other leading byte. + tokenizer.advance(1); + } + } + } + let contents = tokenizer.slice_from(start_position); + check_for_source_map(tokenizer, contents); + contents +} + +fn consume_string<'a>(tokenizer: &mut Tokenizer<'a>, single_quote: bool) -> Token<'a> { + match consume_quoted_string(tokenizer, single_quote) { + Ok(value) => QuotedString(value), + Err(value) => BadString(value), + } +} + +/// Return `Err(())` on syntax error (ie. unescaped newline) +fn consume_quoted_string<'a>( + tokenizer: &mut Tokenizer<'a>, + single_quote: bool, +) -> Result<CowRcStr<'a>, CowRcStr<'a>> { + tokenizer.advance(1); // Skip the initial quote + // start_pos is at code point boundary, after " or ' + let start_pos = tokenizer.position(); + let mut string_bytes; + loop { + if tokenizer.is_eof() { + return Ok(tokenizer.slice_from(start_pos).into()); + } + match_byte! { tokenizer.next_byte_unchecked(), + b'"' => { + if !single_quote { + let value = tokenizer.slice_from(start_pos); + tokenizer.advance(1); + return Ok(value.into()) + } + tokenizer.advance(1); + } + b'\'' => { + if single_quote { + let value = tokenizer.slice_from(start_pos); + tokenizer.advance(1); + return Ok(value.into()) + } + tokenizer.advance(1); + } + b'\\' | b'\0' => { + // * The tokenizer’s input is UTF-8 since it’s `&str`. + // * start_pos is at a code point boundary + // * so is the current position (which is before '\\' or '\0' + // + // So `string_bytes` is well-formed UTF-8. + string_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned(); + break + } + b'\n' | b'\r' | b'\x0C' => { + return Err(tokenizer.slice_from(start_pos).into()) + }, + b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); } + b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); } + _ => { + // ASCII or other leading byte. + tokenizer.advance(1); + } + } + } + + while !tokenizer.is_eof() { + let b = tokenizer.next_byte_unchecked(); + match_byte! { b, + b'\n' | b'\r' | b'\x0C' => { + return Err( + // string_bytes is well-formed UTF-8, see other comments. + unsafe { + from_utf8_release_unchecked(string_bytes) + }.into() + ); + } + b'"' => { + tokenizer.advance(1); + if !single_quote { + break; + } + } + b'\'' => { + tokenizer.advance(1); + if single_quote { + break; + } + } + b'\\' => { + tokenizer.advance(1); + if !tokenizer.is_eof() { + match tokenizer.next_byte_unchecked() { + // Escaped newline + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + // This pushes one well-formed code point + _ => consume_escape_and_write(tokenizer, &mut string_bytes) + } + } + // else: escaped EOF, do nothing. + continue; + } + b'\0' => { + tokenizer.advance(1); + string_bytes.extend("\u{FFFD}".as_bytes()); + continue; + } + b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); } + b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); } + _ => { + // ASCII or other leading byte. + tokenizer.advance(1); + }, + } + + // If this byte is part of a multi-byte code point, + // we’ll end up copying the whole code point before this loop does something else. + string_bytes.push(b); + } + + Ok( + // string_bytes is well-formed UTF-8, see other comments. + unsafe { from_utf8_release_unchecked(string_bytes) }.into(), + ) +} + +#[inline] +fn is_ident_start(tokenizer: &mut Tokenizer) -> bool { + !tokenizer.is_eof() + && match_byte! { tokenizer.next_byte_unchecked(), + b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'\0' => true, + b'-' => { + tokenizer.has_at_least(1) && match_byte! { tokenizer.byte_at(1), + b'a'..=b'z' | b'A'..=b'Z' | b'-' | b'_' | b'\0' => { + true + } + b'\\' => !tokenizer.has_newline_at(1), + b => !b.is_ascii(), + } + }, + b'\\' => !tokenizer.has_newline_at(1), + b => !b.is_ascii(), + } +} + +fn consume_ident_like<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> { + let value = consume_name(tokenizer); + if !tokenizer.is_eof() && tokenizer.next_byte_unchecked() == b'(' { + tokenizer.advance(1); + if value.eq_ignore_ascii_case("url") { + consume_unquoted_url(tokenizer).unwrap_or(Function(value)) + } else { + tokenizer.see_function(&value); + Function(value) + } + } else { + Ident(value) + } +} + +fn consume_name<'a>(tokenizer: &mut Tokenizer<'a>) -> CowRcStr<'a> { + // start_pos is the end of the previous token, therefore at a code point boundary + let start_pos = tokenizer.position(); + let mut value_bytes; + loop { + if tokenizer.is_eof() { + return tokenizer.slice_from(start_pos).into(); + } + match_byte! { tokenizer.next_byte_unchecked(), + b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-' => tokenizer.advance(1), + b'\\' | b'\0' => { + // * The tokenizer’s input is UTF-8 since it’s `&str`. + // * start_pos is at a code point boundary + // * so is the current position (which is before '\\' or '\0' + // + // So `value_bytes` is well-formed UTF-8. + value_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned(); + break + } + b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); } + b'\xC0'..=b'\xEF' => { tokenizer.advance(1); } + b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); } + _b => { + return tokenizer.slice_from(start_pos).into(); + } + } + } + + while !tokenizer.is_eof() { + let b = tokenizer.next_byte_unchecked(); + match_byte! { b, + b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | b'-' => { + tokenizer.advance(1); + value_bytes.push(b) // ASCII + } + b'\\' => { + if tokenizer.has_newline_at(1) { break } + tokenizer.advance(1); + // This pushes one well-formed code point + consume_escape_and_write(tokenizer, &mut value_bytes) + } + b'\0' => { + tokenizer.advance(1); + value_bytes.extend("\u{FFFD}".as_bytes()); + }, + b'\x80'..=b'\xBF' => { + // This byte *is* part of a multi-byte code point, + // we’ll end up copying the whole code point before this loop does something else. + tokenizer.consume_continuation_byte(); + value_bytes.push(b) + } + b'\xC0'..=b'\xEF' => { + // This byte *is* part of a multi-byte code point, + // we’ll end up copying the whole code point before this loop does something else. + tokenizer.advance(1); + value_bytes.push(b) + } + b'\xF0'..=b'\xFF' => { + tokenizer.consume_4byte_intro(); + value_bytes.push(b) + } + _ => { + // ASCII + break; + } + } + } + // string_bytes is well-formed UTF-8, see other comments. + unsafe { from_utf8_release_unchecked(value_bytes) }.into() +} + +fn byte_to_hex_digit(b: u8) -> Option<u32> { + Some(match_byte! { b, + b'0' ..= b'9' => b - b'0', + b'a' ..= b'f' => b - b'a' + 10, + b'A' ..= b'F' => b - b'A' + 10, + _ => { + return None + } + } as u32) +} + +fn byte_to_decimal_digit(b: u8) -> Option<u32> { + if b.is_ascii_digit() { + Some((b - b'0') as u32) + } else { + None + } +} + +fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> { + // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)? + // But this is always called so that there is at least one digit in \d*(\.\d+)? + + // Do all the math in f64 so that large numbers overflow to +/-inf + // and i32::{MIN, MAX} are within range. + + let (has_sign, sign) = match tokenizer.next_byte_unchecked() { + b'-' => (true, -1.), + b'+' => (true, 1.), + _ => (false, 1.), + }; + if has_sign { + tokenizer.advance(1); + } + + let mut integral_part: f64 = 0.; + while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) { + integral_part = integral_part * 10. + digit as f64; + tokenizer.advance(1); + if tokenizer.is_eof() { + break; + } + } + + let mut is_integer = true; + + let mut fractional_part: f64 = 0.; + if tokenizer.has_at_least(1) + && tokenizer.next_byte_unchecked() == b'.' + && tokenizer.byte_at(1).is_ascii_digit() + { + is_integer = false; + tokenizer.advance(1); // Consume '.' + let mut factor = 0.1; + while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) { + fractional_part += digit as f64 * factor; + factor *= 0.1; + tokenizer.advance(1); + if tokenizer.is_eof() { + break; + } + } + } + + let mut value = sign * (integral_part + fractional_part); + + if tokenizer.has_at_least(1) + && matches!(tokenizer.next_byte_unchecked(), b'e' | b'E') + && (tokenizer.byte_at(1).is_ascii_digit() + || (tokenizer.has_at_least(2) + && matches!(tokenizer.byte_at(1), b'+' | b'-') + && tokenizer.byte_at(2).is_ascii_digit())) + { + is_integer = false; + tokenizer.advance(1); + let (has_sign, sign) = match tokenizer.next_byte_unchecked() { + b'-' => (true, -1.), + b'+' => (true, 1.), + _ => (false, 1.), + }; + if has_sign { + tokenizer.advance(1); + } + let mut exponent: f64 = 0.; + while let Some(digit) = byte_to_decimal_digit(tokenizer.next_byte_unchecked()) { + exponent = exponent * 10. + digit as f64; + tokenizer.advance(1); + if tokenizer.is_eof() { + break; + } + } + value *= f64::powf(10., sign * exponent); + } + + let int_value = if is_integer { + Some(if value >= i32::MAX as f64 { + i32::MAX + } else if value <= i32::MIN as f64 { + i32::MIN + } else { + value as i32 + }) + } else { + None + }; + + if !tokenizer.is_eof() && tokenizer.next_byte_unchecked() == b'%' { + tokenizer.advance(1); + return Percentage { + unit_value: (value / 100.) as f32, + int_value, + has_sign, + }; + } + let value = value as f32; + if is_ident_start(tokenizer) { + let unit = consume_name(tokenizer); + Dimension { + value, + int_value, + has_sign, + unit, + } + } else { + Number { + value, + int_value, + has_sign, + } + } +} + +#[inline] +unsafe fn from_utf8_release_unchecked(string_bytes: Vec<u8>) -> String { + if cfg!(debug_assertions) { + String::from_utf8(string_bytes).unwrap() + } else { + String::from_utf8_unchecked(string_bytes) + } +} + +fn consume_unquoted_url<'a>(tokenizer: &mut Tokenizer<'a>) -> Result<Token<'a>, ()> { + // This is only called after "url(", so the current position is a code point boundary. + let start_position = tokenizer.position; + let from_start = &tokenizer.input[tokenizer.position..]; + let mut newlines = 0; + let mut last_newline = 0; + let mut found_printable_char = false; + let mut iter = from_start.bytes().enumerate(); + loop { + let (offset, b) = match iter.next() { + Some(item) => item, + None => { + tokenizer.position = tokenizer.input.len(); + break; + } + }; + match_byte! { b, + b' ' | b'\t' => {}, + b'\n' | b'\x0C' => { + newlines += 1; + last_newline = offset; + } + b'\r' => { + if from_start.as_bytes().get(offset + 1) != Some(&b'\n') { + newlines += 1; + last_newline = offset; + } + } + b'"' | b'\'' => return Err(()), // Do not advance + b')' => { + // Don't use advance, because we may be skipping + // newlines here, and we want to avoid the assert. + tokenizer.position += offset + 1; + break + } + _ => { + // Don't use advance, because we may be skipping + // newlines here, and we want to avoid the assert. + tokenizer.position += offset; + found_printable_char = true; + break + } + } + } + + if newlines > 0 { + tokenizer.current_line_number += newlines; + // No need for wrapping_add here, because there's no possible + // way to wrap. + tokenizer.current_line_start_position = start_position + last_newline + 1; + } + + if found_printable_char { + // This function only consumed ASCII (whitespace) bytes, + // so the current position is a code point boundary. + return Ok(consume_unquoted_url_internal(tokenizer)); + } else { + return Ok(UnquotedUrl("".into())); + } + + fn consume_unquoted_url_internal<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> { + // This function is only called with start_pos at a code point boundary. + let start_pos = tokenizer.position(); + let mut string_bytes: Vec<u8>; + loop { + if tokenizer.is_eof() { + return UnquotedUrl(tokenizer.slice_from(start_pos).into()); + } + match_byte! { tokenizer.next_byte_unchecked(), + b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' => { + let value = tokenizer.slice_from(start_pos); + return consume_url_end(tokenizer, start_pos, value.into()) + } + b')' => { + let value = tokenizer.slice_from(start_pos); + tokenizer.advance(1); + return UnquotedUrl(value.into()) + } + b'\x01'..=b'\x08' | b'\x0B' | b'\x0E'..=b'\x1F' | b'\x7F' // non-printable + | b'"' | b'\'' | b'(' => { + tokenizer.advance(1); + return consume_bad_url(tokenizer, start_pos) + }, + b'\\' | b'\0' => { + // * The tokenizer’s input is UTF-8 since it’s `&str`. + // * start_pos is at a code point boundary + // * so is the current position (which is before '\\' or '\0' + // + // So `string_bytes` is well-formed UTF-8. + string_bytes = tokenizer.slice_from(start_pos).as_bytes().to_owned(); + break + } + b'\x80'..=b'\xBF' => { tokenizer.consume_continuation_byte(); } + b'\xF0'..=b'\xFF' => { tokenizer.consume_4byte_intro(); } + _ => { + // ASCII or other leading byte. + tokenizer.advance(1); + } + } + } + while !tokenizer.is_eof() { + let b = tokenizer.next_byte_unchecked(); + match_byte! { b, + b' ' | b'\t' | b'\n' | b'\r' | b'\x0C' => { + // string_bytes is well-formed UTF-8, see other comments. + let string = unsafe { from_utf8_release_unchecked(string_bytes) }.into(); + return consume_url_end(tokenizer, start_pos, string) + } + b')' => { + tokenizer.advance(1); + break; + } + b'\x01'..=b'\x08' | b'\x0B' | b'\x0E'..=b'\x1F' | b'\x7F' // non-printable + | b'"' | b'\'' | b'(' => { + tokenizer.advance(1); + return consume_bad_url(tokenizer, start_pos); + } + b'\\' => { + tokenizer.advance(1); + if tokenizer.has_newline_at(0) { + return consume_bad_url(tokenizer, start_pos) + } + + // This pushes one well-formed code point to string_bytes + consume_escape_and_write(tokenizer, &mut string_bytes) + }, + b'\0' => { + tokenizer.advance(1); + string_bytes.extend("\u{FFFD}".as_bytes()); + } + b'\x80'..=b'\xBF' => { + // We’ll end up copying the whole code point + // before this loop does something else. + tokenizer.consume_continuation_byte(); + string_bytes.push(b); + } + b'\xF0'..=b'\xFF' => { + // We’ll end up copying the whole code point + // before this loop does something else. + tokenizer.consume_4byte_intro(); + string_bytes.push(b); + } + // If this byte is part of a multi-byte code point, + // we’ll end up copying the whole code point before this loop does something else. + b => { + // ASCII or other leading byte. + tokenizer.advance(1); + string_bytes.push(b) + } + } + } + UnquotedUrl( + // string_bytes is well-formed UTF-8, see other comments. + unsafe { from_utf8_release_unchecked(string_bytes) }.into(), + ) + } + + fn consume_url_end<'a>( + tokenizer: &mut Tokenizer<'a>, + start_pos: SourcePosition, + string: CowRcStr<'a>, + ) -> Token<'a> { + while !tokenizer.is_eof() { + match_byte! { tokenizer.next_byte_unchecked(), + b')' => { + tokenizer.advance(1); + break + } + b' ' | b'\t' => { tokenizer.advance(1); } + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + b => { + tokenizer.consume_known_byte(b); + return consume_bad_url(tokenizer, start_pos); + } + } + } + UnquotedUrl(string) + } + + fn consume_bad_url<'a>(tokenizer: &mut Tokenizer<'a>, start_pos: SourcePosition) -> Token<'a> { + // Consume up to the closing ) + while !tokenizer.is_eof() { + match_byte! { tokenizer.next_byte_unchecked(), + b')' => { + let contents = tokenizer.slice_from(start_pos).into(); + tokenizer.advance(1); + return BadUrl(contents) + } + b'\\' => { + tokenizer.advance(1); + if matches!(tokenizer.next_byte(), Some(b')') | Some(b'\\')) { + tokenizer.advance(1); // Skip an escaped ')' or '\' + } + } + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + b => { + tokenizer.consume_known_byte(b); + } + } + } + BadUrl(tokenizer.slice_from(start_pos).into()) + } +} + +// (value, number of digits up to 6) +fn consume_hex_digits(tokenizer: &mut Tokenizer<'_>) -> (u32, u32) { + let mut value = 0; + let mut digits = 0; + while digits < 6 && !tokenizer.is_eof() { + match byte_to_hex_digit(tokenizer.next_byte_unchecked()) { + Some(digit) => { + value = value * 16 + digit; + digits += 1; + tokenizer.advance(1); + } + None => break, + } + } + (value, digits) +} + +// Same constraints as consume_escape except it writes into `bytes` the result +// instead of returning it. +fn consume_escape_and_write(tokenizer: &mut Tokenizer, bytes: &mut Vec<u8>) { + bytes.extend( + consume_escape(tokenizer) + .encode_utf8(&mut [0; 4]) + .as_bytes(), + ) +} + +// Assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed +// and that the next input character has already been verified +// to not be a newline. +fn consume_escape(tokenizer: &mut Tokenizer) -> char { + if tokenizer.is_eof() { + return '\u{FFFD}'; + } // Escaped EOF + match_byte! { tokenizer.next_byte_unchecked(), + b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f' => { + let (c, _) = consume_hex_digits(tokenizer); + if !tokenizer.is_eof() { + match_byte! { tokenizer.next_byte_unchecked(), + b' ' | b'\t' => { + tokenizer.advance(1) + } + b'\n' | b'\x0C' | b'\r' => { + tokenizer.consume_newline(); + } + _ => {} + } + } + static REPLACEMENT_CHAR: char = '\u{FFFD}'; + if c != 0 { + let c = char::from_u32(c); + c.unwrap_or(REPLACEMENT_CHAR) + } else { + REPLACEMENT_CHAR + } + }, + b'\0' => { + tokenizer.advance(1); + '\u{FFFD}' + } + _ => tokenizer.consume_char(), + } +}
diff --git a/src/unicode_range.rs b/src/unicode_range.rs new file mode 100644 index 0000000..a4130ef --- /dev/null +++ b/src/unicode_range.rs
@@ -0,0 +1,183 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//! https://drafts.csswg.org/css-syntax/#urange + +use crate::tokenizer::Token; +use crate::{BasicParseError, Parser, ToCss}; +use std::char; +use std::fmt; + +/// One contiguous range of code points. +/// +/// Can not be empty. Can represent a single code point when start == end. +#[derive(PartialEq, Eq, Clone, Hash)] +#[repr(C)] +pub struct UnicodeRange { + /// Inclusive start of the range. In [0, end]. + pub start: u32, + + /// Inclusive end of the range. In [0, 0x10FFFF]. + pub end: u32, +} + +impl UnicodeRange { + /// https://drafts.csswg.org/css-syntax/#urange-syntax + pub fn parse<'i>(input: &mut Parser<'i, '_>) -> Result<Self, BasicParseError<'i>> { + // <urange> = + // u '+' <ident-token> '?'* | + // u <dimension-token> '?'* | + // u <number-token> '?'* | + // u <number-token> <dimension-token> | + // u <number-token> <number-token> | + // u '+' '?'+ + + input.expect_ident_matching("u")?; + let after_u = input.position(); + parse_tokens(input)?; + + // This deviates from the spec in case there are CSS comments + // between tokens in the middle of one <unicode-range>, + // but oh well… + let concatenated_tokens = input.slice_from(after_u); + + let range = match parse_concatenated(concatenated_tokens.as_bytes()) { + Ok(range) => range, + Err(()) => { + return Err(input + .new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into()))) + } + }; + if range.end > char::MAX as u32 || range.start > range.end { + Err(input.new_basic_unexpected_token_error(Token::Ident(concatenated_tokens.into()))) + } else { + Ok(range) + } + } +} + +fn parse_tokens<'i>(input: &mut Parser<'i, '_>) -> Result<(), BasicParseError<'i>> { + match input.next_including_whitespace()?.clone() { + Token::Delim('+') => { + match *input.next_including_whitespace()? { + Token::Ident(_) => {} + Token::Delim('?') => {} + ref t => { + let t = t.clone(); + return Err(input.new_basic_unexpected_token_error(t)); + } + } + parse_question_marks(input) + } + Token::Dimension { .. } => parse_question_marks(input), + Token::Number { .. } => { + let after_number = input.state(); + match input.next_including_whitespace() { + Ok(&Token::Delim('?')) => parse_question_marks(input), + Ok(&Token::Dimension { .. }) => {} + Ok(&Token::Number { .. }) => {} + _ => input.reset(&after_number), + } + } + t => return Err(input.new_basic_unexpected_token_error(t)), + } + Ok(()) +} + +/// Consume as many '?' as possible +fn parse_question_marks(input: &mut Parser) { + loop { + let start = input.state(); + match input.next_including_whitespace() { + Ok(&Token::Delim('?')) => {} + _ => { + input.reset(&start); + return; + } + } + } +} + +fn parse_concatenated(text: &[u8]) -> Result<UnicodeRange, ()> { + let mut text = match text.split_first() { + Some((&b'+', text)) => text, + _ => return Err(()), + }; + let (first_hex_value, hex_digit_count) = consume_hex(&mut text, 6)?; + let question_marks = consume_question_marks(&mut text); + let consumed = hex_digit_count + question_marks; + if consumed == 0 || consumed > 6 { + return Err(()); + } + + if question_marks > 0 { + if text.is_empty() { + return Ok(UnicodeRange { + start: first_hex_value << (question_marks * 4), + end: ((first_hex_value + 1) << (question_marks * 4)) - 1, + }); + } + } else if text.is_empty() { + return Ok(UnicodeRange { + start: first_hex_value, + end: first_hex_value, + }); + } else if let Some((&b'-', mut text)) = text.split_first() { + let (second_hex_value, hex_digit_count) = consume_hex(&mut text, 6)?; + if hex_digit_count > 0 && hex_digit_count <= 6 && text.is_empty() { + return Ok(UnicodeRange { + start: first_hex_value, + end: second_hex_value, + }); + } + } + Err(()) +} + +// Consume hex digits, but return an error if more than digit_limit are found. +fn consume_hex(text: &mut &[u8], digit_limit: usize) -> Result<(u32, usize), ()> { + let mut value = 0; + let mut digits = 0; + while let Some((&byte, rest)) = text.split_first() { + if let Some(digit_value) = (byte as char).to_digit(16) { + if digits == digit_limit { + return Err(()); + } + value = value * 0x10 + digit_value; + digits += 1; + *text = rest; + } else { + break; + } + } + Ok((value, digits)) +} + +fn consume_question_marks(text: &mut &[u8]) -> usize { + let mut question_marks = 0; + while let Some((&b'?', rest)) = text.split_first() { + question_marks += 1; + *text = rest + } + question_marks +} + +impl fmt::Debug for UnicodeRange { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + self.to_css(formatter) + } +} + +impl ToCss for UnicodeRange { + fn to_css<W>(&self, dest: &mut W) -> fmt::Result + where + W: fmt::Write, + { + write!(dest, "U+{:X}", self.start)?; + if self.end != self.start { + write!(dest, "-{:X}", self.end)?; + } + Ok(()) + } +}