diff --git a/.gitignore b/.gitignore index 86e4022..a7064fe 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ __pycache__/ .ipynb_checkpoints/ .pytest_cache/ .python-version +.venv/ # vendor and build files dist/ @@ -14,7 +15,6 @@ docs/_autosummary/ docs/_build/ # local -notebooks/ /Makefile data/ diff --git a/DESIGN.md b/DESIGN.md index ec37513..4f0764a 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -86,18 +86,18 @@ reach >4.5 WCAG 2 contrast ratio (the standard requirement for small text on the web) against all biome monotones for each theme: + For BG l20 (harsh, dark) -> l65 is min lightness where all accents have CR - >=4.5 + ≥4.5 + For BG l25 (regular, dark) -> l65 is min lightness where all accents have CR - >=4.5 + ≥4.5 + For BG l30 (soft, dark) -> l70 is min lightness where all accents have CR - >=4.5 + ≥4.5 + For BG l90 (harsh, dark) -> l45 is max lightness where all accents have CR - >=4.5 + ≥4.5 + For BG l85 (regular, dark) -> l45 is min lightness where all accents have CR - >=4.5 + ≥4.5 + For BG l80 (soft, dark) -> l40 is min lightness where all accents have CR - >=4.5 + ≥4.5 For the monotone boundaries (l15 and l95, neither of which are possible backgrounds for terminal or nvim in the current theme definitions), the diff --git a/notebooks/color_spaces.ipynb b/notebooks/color_spaces.ipynb new file mode 100644 index 0000000..2cb5d75 --- /dev/null +++ b/notebooks/color_spaces.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1abfc7de-3ced-4407-b38e-3fc276b6a133", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import json\n", + "from pathlib import Path\n", + "\n", + "import plotly.io as pio\n", + "import plotly.graph_objects as go\n", + "from coloraide import Color\n", + "\n", + "import gamut_3d_plotly as diagrams\n", + "\n", + "pio.renderers\n", + "pio.renderers.default = \"notebook_connected\"\n", + "\n", + "\n", + "def face_radial_plane(fig, theta_deg, r=2.5, tilt_deg=0):\n", + " # normal in xy\n", + " nx = -math.sin(math.radians(theta_deg))\n", + " ny = math.cos(math.radians(theta_deg))\n", + "\n", + " # allow optional tilt up/down so it's not perfectly horizontal\n", + " tilt = math.radians(tilt_deg) # 0 => horizontal view, positive looks slightly downward\n", + " ex = r * nx * math.cos(tilt)\n", + " ey = r * ny * math.cos(tilt)\n", + " ez = r * math.sin(tilt)\n", + "\n", + " fig.update_layout(\n", + " scene_camera=dict(\n", + " eye=dict(x=ex, y=ey, z=ez),\n", + " center=dict(x=0, y=0, z=0),\n", + " up=dict(x=0, y=0, z=1)\n", + " )\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "642b3763-f250-4e24-bd4c-2a080772467d", + "metadata": {}, + "outputs": [], + "source": [ + "PALETTE_DIR = \"palettes\"\n", + "\n", + "with Path(PALETTE_DIR, \"monobiome-v111-oklch.json\").open(\"rb\") as f:\n", + " mb_v111_dict = json.load(f)\n", + "with Path(PALETTE_DIR, \"monobiome-vUCC-oklch.json\").open(\"rb\") as f:\n", + " mb_vUCC_dict = json.load(f)\n", + "with Path(PALETTE_DIR, \"monobiome-vMCL-oklch.json\").open(\"rb\") as f:\n", + " mb_vMCL_dict = json.load(f)\n", + "with Path(PALETTE_DIR, \"monobiome-vQBR-oklch.json\").open(\"rb\") as f:\n", + " mb_vQBR_dict = json.load(f)\n", + "with Path(PALETTE_DIR, \"monobiome-vQBRsn-oklch.json\").open(\"rb\") as f:\n", + " mb_vQBRsn_dict = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0e778a92-78fa-40eb-8b4f-51fbbbc9eb0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===> Generating oklch model...\n" + ] + }, + { + "data": { + "text/html": [ + " \n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "name = 'oklch'\n", + "gamut = 'srgb'\n", + "title = f'{name} color space'\n", + "\n", + "# elev=45\n", + "# azim=-60.0\n", + "elev=45\n", + "azim=29.0\n", + "width = 600\n", + "height = 400\n", + "\n", + "print(f'===> Generating {name} model...')\n", + "fig = diagrams.plot_gamut_in_space(\n", + " name,\n", + " gamuts={\n", + " gamut: {\n", + " 'opacity': 0.2,\n", + " # 'edges': 'black',\n", + " # 'faces': True,\n", + " }\n", + " },\n", + " # dark=True,\n", + " gmap={'method': 'raytrace'},\n", + " title=title,\n", + " size=(width, height),\n", + " camera={'a': azim, 'e': elev, 'r': 2.5},\n", + " projection='orthographic',\n", + ")\n", + "\n", + "fig.update_layout(\n", + " margin=dict(l=0, r=0, t=0, b=0)\n", + ")\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ed02f2b8-ea4e-43f1-bec6-914b1b3ccccf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trajectory = [Color(c_str) for c_str in mb_dict[\"badlands\"].values()]\n", + "trajectories = [ [Color(c_str) for c_str in c_str_dict.values()] for c_str_dict in mb_v111_dict.values()] \n", + "\n", + "tmp_fig = go.Figure(fig)\n", + "\n", + "for trajectory in trajectories:\n", + " diagrams.plot_trajectory(\n", + " tmp_fig,\n", + " space=\"oklab\",\n", + " trajectory_colors=trajectory,\n", + " gmap={'method': 'raytrace'},\n", + " filters=(),\n", + " connect_line=True,\n", + " marker_size=2,\n", + " line_width=2,\n", + " # simulate_alpha=False\n", + " )\n", + "\n", + "face_radial_plane(tmp_fig, 29)\n", + "tmp_fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e2c781cc-f8a9-49f0-9488-e380897f5c9a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trajectory = [Color(c_str) for c_str in mb_dict[\"badlands\"].values()]\n", + "trajectories = [ [Color(c_str) for c_str in c_str_dict.values()] for c_str_dict in mb_vUCC_dict.values()] \n", + "\n", + "tmp_fig = go.Figure(fig)\n", + "\n", + "for trajectory in trajectories:\n", + " diagrams.plot_trajectory(\n", + " tmp_fig,\n", + " space=\"oklab\",\n", + " trajectory_colors=trajectory,\n", + " gmap={'method': 'raytrace'},\n", + " filters=(),\n", + " connect_line=True,\n", + " marker_size=2,\n", + " line_width=2,\n", + " # simulate_alpha=False\n", + " )\n", + "\n", + "tmp_fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "521ce16e-82bc-4169-8a1b-65a353f9acea", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trajectory = [Color(c_str) for c_str in mb_dict[\"badlands\"].values()]\n", + "trajectories = [ [Color(c_str) for c_str in c_str_dict.values()] for c_str_dict in mb_vMCL_dict.values()] \n", + "\n", + "tmp_fig = go.Figure(fig)\n", + "\n", + "for trajectory in trajectories:\n", + " diagrams.plot_trajectory(\n", + " tmp_fig,\n", + " space=\"oklab\",\n", + " trajectory_colors=trajectory,\n", + " gmap={'method': 'raytrace'},\n", + " filters=(),\n", + " connect_line=True,\n", + " marker_size=2,\n", + " line_width=2,\n", + " # simulate_alpha=False\n", + " )\n", + "\n", + "tmp_fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4c088f0e-74d1-4bab-bf40-b0e9af5713bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trajectory = [Color(c_str) for c_str in mb_dict[\"badlands\"].values()]\n", + "trajectories = [ [Color(c_str) for c_str in c_str_dict.values()] for c_str_dict in mb_vQBR_dict.values()] \n", + "\n", + "tmp_fig = go.Figure(fig)\n", + "\n", + "for trajectory in trajectories:\n", + " diagrams.plot_trajectory(\n", + " tmp_fig,\n", + " space=\"oklab\",\n", + " trajectory_colors=trajectory,\n", + " gmap={'method': 'raytrace'},\n", + " filters=(),\n", + " connect_line=True,\n", + " marker_size=2,\n", + " line_width=2,\n", + " # simulate_alpha=False\n", + " )\n", + "\n", + "face_radial_plane(tmp_fig, 29)\n", + "tmp_fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "32f3f70d-2ce7-4bdb-ad75-58a9193ca491", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trajectory = [Color(c_str) for c_str in mb_dict[\"badlands\"].values()]\n", + "trajectories = [ [Color(c_str) for c_str in c_str_dict.values()] for c_str_dict in mb_vQBRsn_dict.values()] \n", + "\n", + "tmp_fig = go.Figure(fig)\n", + "\n", + "for trajectory in trajectories:\n", + " diagrams.plot_trajectory(\n", + " tmp_fig,\n", + " space=\"oklab\",\n", + " trajectory_colors=trajectory,\n", + " gmap={'method': 'raytrace'},\n", + " filters=(),\n", + " connect_line=True,\n", + " marker_size=2,\n", + " line_width=2,\n", + " opacity=0.5,\n", + " # simulate_alpha=True\n", + " )\n", + "\n", + "face_radial_plane(tmp_fig, 29)\n", + "tmp_fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9f5ac6ad-dde8-4570-ae6c-43dfa28f655c", + "metadata": {}, + "outputs": [], + "source": [ + "#import plotly.graph_objects as go\n", + "# tmp_fig = go.Figure(base_fig) with open(f'{name}-space.png', 'wb') as f:\n", + "# f.write(fig.to_image(format='png', width=width, height=height))\n", + "# print('[complete]')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "monobiome", + "language": "python", + "name": "monobiome" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/gamut_3d_plotly.py b/notebooks/gamut_3d_plotly.py new file mode 100644 index 0000000..8f9d725 --- /dev/null +++ b/notebooks/gamut_3d_plotly.py @@ -0,0 +1,1021 @@ +# adapted from the Coloraide Python package +# file: https://github.com/facelessuser/coloraide/blob/main/tools/gamut_3d_plotly.py + +"""Plot color space using Plotly.""" +import sys +import argparse +from scipy.spatial import Delaunay +import plotly.graph_objects as go +import math +import plotly.io as io +import os +import json + +sys.path.insert(0, os.getcwd()) + +try: + from coloraide_extras.everything import ColorAll as Color +except ImportError: + from coloraide.everything import ColorAll as Color +from coloraide.spaces import HSLish, HSVish, HWBish, Labish, LChish, RGBish # noqa: E402 +from coloraide import algebra as alg # noqa: E402 + +FORCE_OWN_GAMUT = {'ryb', 'ryb-biased'} + + +def get_face_color(cmap, simplex, filters): + """Get best color.""" + + return Color.average([cmap[simplex[0]], cmap[simplex[1]], cmap[simplex[2]]], space='srgb').to_string(hex=True) + + +def create_custom_hsl(gamut): + """Create a custom color object that has access to a special `hsl-gamut` space to map surface in.""" + + cs = Color.CS_MAP[gamut] + hsl = Color.CS_MAP['hsl'] + scale = not isinstance(cs, RGBish) + + class HSL(type(hsl)): + NAME = f'-hsl-{gamut}' + BASE = gamut + GAMUT_CHECK = gamut + CLIP_SPACE = None + WHITE = cs.WHITE + DYAMIC_RANGE = cs.DYNAMIC_RANGE + INDEXES = cs.indexes() + + # Scale channels as needed + OFFSET_1 = cs.channels[INDEXES[0]].low if scale else 0.0 + OFFSET_2 = cs.channels[INDEXES[1]].low if scale else 0.0 + OFFSET_3 = cs.channels[INDEXES[2]].low if scale else 0.0 + + SCALE_1 = cs.channels[INDEXES[0]].high if scale else 1.0 + SCALE_2 = cs.channels[INDEXES[1]].high if scale else 1.0 + SCALE_3 = cs.channels[INDEXES[2]].high if scale else 1.0 + + def to_base(self, coords): + """Convert from RGB to HSL.""" + + # Convert from HSL back to its original space + coords = hsl.to_base(coords) + # Scale and offset the values back to the origin space's configuration + coords[0] = coords[0] * (self.SCALE_1 - self.OFFSET_1) + self.OFFSET_1 + coords[1] = coords[1] * (self.SCALE_2 - self.OFFSET_2) + self.OFFSET_2 + coords[2] = coords[2] * (self.SCALE_3 - self.OFFSET_3) + self.OFFSET_3 + ordered = [0.0, 0.0, 0.0] + # Consistently order a given color spaces points based on its type + for e, c in enumerate(coords): + ordered[self.INDEXES[e]] = c + return ordered + + def from_base(self, coords): + """Convert from HSL to RGB.""" + + # Undo order a given color spaces points based on its type + coords = [coords[i] for i in self.INDEXES] + # Scale and offset the values such that channels are between 0 - 1 + coords[0] = (coords[0] - self.OFFSET_1) / (self.SCALE_1 - self.OFFSET_1) + coords[1] = (coords[1] - self.OFFSET_2) / (self.SCALE_2 - self.OFFSET_2) + coords[2] = (coords[2] - self.OFFSET_3) / (self.SCALE_3 - self.OFFSET_3) + # Convert to HSL + return hsl.from_base(coords) + + class ColorCyl(Color): + """Custom color.""" + + ColorCyl.register(HSL()) + + return ColorCyl + + +def create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters): + """Create the 3D renders.""" + + i, j, k = tri.simplices.T + if opacity: + mesh = go.Mesh3d( + x=x, + y=y, + z=z, + i=i, + j=j, + k=k, + vertexcolor=cmap if not faces else None, + facecolor=[ + get_face_color(cmap, t, filters) if not fcolor else fcolor for t in tri.simplices + ] if faces else None, + flatshading = True, + lighting = {"vertexnormalsepsilon": 0, "facenormalsepsilon": 0} + ) + mesh.update(hoverinfo='skip') + mesh.update(opacity=opacity) + fig.add_traces([mesh]) + + if edges: + # Draw the triangles, but ensure they are separate by adding `None` to the end. + xe = [] + ye = [] + ze = [] + tri_colors = [] + for p0, p1, p2 in tri.simplices: + xe.extend([x[p0], x[p1], x[p2], x[p0], None]) + ye.extend([y[p0], y[p1], y[p2], y[p0], None]) + ze.extend([z[p0], z[p1], z[p2], z[p0], None]) + if ecolor is None: + tri_colors.extend([cmap[p0], cmap[p1], cmap[p2], cmap[p0], '#000000']) + + # Use a single color for edges. + if ecolor is not None: + tri_colors = ecolor + + lines = go.Scatter3d( + x=xe, + y=ye, + z=ze, + mode='lines', + marker={'size':0}, + showlegend=False, + name='', + line={'color': tri_colors} + ) + lines.update(hoverinfo='skip') + fig.add_traces([lines]) + + +def cyl_disc( + fig, + ColorCyl, + space, + gamut, + location, + resolution, + opacity, + edges, + faces, + ecolor, + fcolor, + gmap, + flags, + filters +): + """ + Plot cylindrical disc on either top or bottom of an RGB cylinder. + + Expectation is either a HSL, HSV, or HSB style cylinder. + """ + + cs = ColorCyl.CS_MAP[gamut] + factor = cs.channels[1].high + + # Using a lightness of 0 can sometimes cause the bottom not to show with certain resolutions, so use a very + # small value instead. + zpos = 1e-16 if location == 'bottom' else 1.0 * factor + + x = [] + y = [] + z = [] + u = [] + v = [] + cmap = [] + + # Interpolate a circle on the outer edge + s1 = ColorCyl.steps( + [ColorCyl(gamut, [hue, 1 * factor, 1 * zpos]) for hue in alg.linspace(0, 360, 2, endpoint=True)], + steps=max(7, (resolution // 6) * 6 + 1), + space=gamut, + hue='specified' + ) + s2 = ColorCyl(gamut, [alg.NaN, 1e-16, alg.NaN]) + + # Interpolate concentric circles to the center of the disc + step = int(resolution / 2) + for r in range(step): + for t1 in s1: + s2['hue'] = t1['hue'] + c = t1.mix(s2, r / (step - 1), space=gamut, hue='specified') + hue = c._space.hue_index() + radius = c._space.radial_index() + u.append(c[radius]) + v.append(c[hue]) + c.convert(space, norm=False, in_place=True) + + store_coords(c, x, y, z, flags) + + # Ensure colors fit in output color gamut. + s = c.convert('srgb') + if not s.in_gamut(): + s.fit(**gmap) + else: + s.clip() + + if filters: + s.filter(filters[0], **filters[1], in_place=True, out_space=s.space()).clip() + + cmap.append(s.to_string(hex=True)) + + # Calculate triangles + tri = Delaunay([*zip(u, v)]) + + create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters) + + +def store_coords(c, x, y, z, flags): + """Store coordinates.""" + + # LCh spaces + if flags['is_lchish']: + light, chroma, hue = c._space.names() + a, b = alg.polar_to_rect(c[chroma], c[hue]) + x.append(a) + y.append(b) + z.append(c[light]) + + # HSL, HSV, or HWB spaces + elif flags['is_hslish'] or flags['is_hsvish'] or flags['is_hwbish']: + hue, sat, light = c._space.names() + a, b = alg.polar_to_rect(c[sat], c[hue]) + x.append(a) + y.append(b) + z.append(c[light]) + + # Any other generic cylindrical space that doesn't fit in the categories above. + elif flags['is_cyl']: + hue = c._space.hue_index() + radius = c._space.radial_index() + a, b = alg.polar_to_rect(c[radius], c[hue]) + x.append(a) + y.append(b) + z.append(c[3 - hue - radius]) + + # Lab spaces + elif flags['is_labish']: + light, a, b = c._space.names() + x.append(c[a]) + y.append(c[b]) + z.append(c[light]) + + # Non-cylindrical spaces could be done here, but normally are not. + else: + x.append(c[0]) + y.append(c[1]) + z.append(c[2]) + + +def render_space_cyl(fig, space, gamut, resolution, opacity, edges, faces, ecolor, fcolor, gmap, filters): + """Renders the color space using an HSL cylinder that is then mapped to the given space.""" + + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + # Determine the gamut mapping space to use. + # Some spaces cannot be generalized (HWB and HPLuv for instance). + if flags['is_hwbish']: + ColorCyl = Color + gspace = space + elif Color.CS_MAP[gamut].is_polar(): + ColorCyl = Color + gspace = gamut + else: + _gamut = space if space in FORCE_OWN_GAMUT else gamut + ColorCyl = create_custom_hsl(_gamut) + gspace = f'-hsl-{_gamut}' + cs = ColorCyl.CS_MAP[gspace] + + # Adjust scaling factor if the mapping space requires it + factor = cs.channels[1].high + + # Render the two halves of the cylinder + u = [] + v = [] + x = [] + y = [] + z = [] + cmap = [] + + # Interpolate the cylinder from 0 to 360 degrees. + # Include, at the very least, 6 evenly spaced hues, and at higher resolutions + # will include a multiple that will include the same 6 key points. + # In HSL, this will cover all the corners of the RGB space. + s1 = ColorCyl.steps( + [ColorCyl(gspace, [hue, 1 * factor, 1 * factor]) for hue in alg.linspace(0, 360, 2, endpoint=True)], + steps=max(7, (resolution // 6) * 6 + 1), + space=gspace, + hue='specified' + ) + # A generic color at the bottom of the space which we can rotate for + # interpolation by changing the hue. + s2 = ColorCyl(gspace, [alg.NaN, 1 * factor, 1e-16]) + + # Create a 3D mesh by interpolating ring at each lightness down the cylinder side. + # Include at least 3 points of lightness: lightest, darkest, and mid, which in + # HSL is the most colorful colors. + for color in s1: + s2['hue'] = color['hue'] + for c in ColorCyl.steps([color, s2], steps=max(3, (resolution // 2) * 2 + 1), space=gspace, hue='specified'): + u.append(c[2]) + v.append(c['hue']) + c.convert(space, norm=False, in_place=True) + + store_coords(c, x, y, z, flags) + + # Adjust gamut to fit the display space + s = c.convert('srgb') + if not s.in_gamut(): + s.fit(**gmap) + else: + s.clip() + + if filters: + s.filter(filters[0], **filters[1], in_place=True, out_space=s.space()).clip() + + cmap.append(s.to_string(hex=True)) + + # Calculate the triangles + tri = Delaunay([*zip(u, v)]) + + create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters) + + # Generate tops for spaces that do not normally get tops automatically. + if flags['is_hwbish'] or (flags['is_cyl'] and not flags['is_lchish']) or isinstance(cs, HSVish): + cyl_disc( + fig, ColorCyl, space, gspace, 'top', resolution, opacity, edges, faces, ecolor, fcolor, gmap, flags, filters + ) + cyl_disc( + fig, ColorCyl, space, gspace, 'bottom', resolution, opacity, edges, faces, ecolor, fcolor, gmap, flags, filters + ) + + return fig + + +def plot_gamut_in_space( + space, + gamuts, + title="", + dark=False, + gmap=None, + size=(800, 800), + camera=None, + aspect=None, + projection='perspective', + filters=() +): + """Plot the given space in sRGB.""" + + if gmap is None: + gmap = {} + + io.templates.default = 'plotly_dark' if dark else 'plotly' + + if camera is None: + camera = {'a': 45, 'e': 45, 'r': math.sqrt(1.25 ** 2 + 1.25 ** 2 + 1.25 ** 2)} + + a = math.radians((90 - camera['a']) % 360) + e = math.radians(90 - camera['e']) + r = camera['r'] + y = r * math.sin(e) * math.cos(a) + x = r * math.sin(e) * math.sin(a) + z = r * math.cos(e) + + if aspect is None: + aspect = {'x': 1, 'y': 1, 'z': 1} + + # Get names for + target = Color.CS_MAP[space] + if len(target.CHANNELS) > 3: + print('Color spaces with dimensions greater than 3 are not supported') + return None + + names = target.CHANNELS + is_cyl = target.is_polar() + is_labish = isinstance(target, Labish) + is_lchish = isinstance(target, LChish) + is_hslish_hsvish = isinstance(target, (HSLish, HSVish)) + + # Setup axes + if is_labish: + c1, c2, c3 = target.indexes() + axm = [c2, c3, c1] + elif is_lchish: + c1, c2, c3 = target.indexes() + axm = [c3, c2, c1] + elif is_hslish_hsvish: + axm = [0, 1, 2] + else: + axm = [0, 1, 2] + + showbackground = True + backgroundcolor = "rgb(230, 230, 230)" if not dark else '#282830' + gridcolor = "rgb(255, 255, 255)" if not dark else '#111' + zerolinecolor = "rgb(255, 255, 255)" if not dark else '#111' + axis = { + "showbackground": showbackground, + "backgroundcolor": backgroundcolor, + "gridcolor": gridcolor, + "zerolinecolor": zerolinecolor, + } + xaxis = str(names[axm[0]]) if not is_cyl else f"{names[axm[0]]} (0˚ - 360˚)" + yaxis = str(names[axm[1]]) + zaxis = str(names[axm[2]]) + + # Setup plot layout + layout = go.Layout( + # General figure characteristics + title=title, + width=size[0], + height=size[1], + + # Specify scene layout + scene=go.layout.Scene( + xaxis=go.layout.scene.XAxis(title=xaxis, showticklabels=not is_cyl, **axis), + yaxis=go.layout.scene.YAxis(title=yaxis, **axis), + zaxis=go.layout.scene.ZAxis(title=zaxis, **axis), + aspectratio=aspect + ), + + # Control camera position + scene_camera={ + "projection": go.layout.scene.camera.Projection(type=projection), + "center": {"x": 0, "y": 0, "z": 0}, + "up": {"x": 0, "y": 0, "z": 1}, + "eye": {"x": x, "y": y, "z": z} + } + ) + + # Create figure to store the plot + fig = go.Figure(layout=layout) + + for gamut, config in gamuts.items(): + opacity = config.get('opacity', 1) + resolution = config.get('resolution', 200) + edges = config.get('edges', False) + ecolor = None + if isinstance(edges, str): + c = Color(edges).convert('srgb').fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + ecolor = c.to_string(hex=True, alpha=False) + edges = True + faces = config.get('faces', False) + fcolor = '' + if isinstance(faces, str): + c = Color(faces).convert('srgb').fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + fcolor = c.to_string(hex=True, alpha=False) + faces = True + + render_space_cyl(fig, space, gamut, resolution, opacity, edges, faces, ecolor, fcolor, gmap, filters) + + return fig + + +def plot_colors(fig, space, gamut, gmap_colors, colors, gmap, filters=()): + """Plot gamut mapping.""" + + if not gmap_colors and not colors: + return + + gamut_mapping = gmap_colors.split(';') if gmap_colors.strip() else [] + non_mapped = colors.split(';') if colors.strip() else [] + if gamut_mapping or non_mapped: + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + l = len(gamut_mapping) + for i, c in enumerate(gamut_mapping + non_mapped): + c1 = Color(c) + c2 = Color(c).fit(gamut, **gmap) + c1.convert(space, in_place=True) + c2.convert(space, in_place=True) + x = [] + y = [] + z = [] + for c in ([c1, c2] if i < l else [c1]): + store_coords(c, x, y, z, flags) + + c2.convert('srgb', in_place=True).fit(**gmap) + if filters: + c2.filter(filters[0], **filters[1], in_place=True, out_space=c2.space()).clip() + + fig.add_trace( + go.Scatter3d( + x=x, y=y, z=z, + line={'color': 'black', 'width': 2}, + marker={ + 'color': c2.to_string(hex=True, alpha=False), + 'size': [16, 0], + 'opacity': 1, + 'line': {'width': 2} + }, + showlegend=False + ) + ) + + +def plot_interpolation( + fig, + space, + interp_colors, + interp_method, + gmap, + simulate_alpha, + interp_gmap, + filters=() +): + """Plot interpolations.""" + + if not interp_colors: + return + + colors = Color.steps( + interp_colors.split(';'), + **interp_method + ) + + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + x = [] + y = [] + z = [] + cmap = [] + for c in colors: + c.convert(space, in_place=True) + if interp_gmap: + c.fit('srgb', **gmap) + store_coords(c, x, y, z, flags) + c.convert('srgb', in_place=True) + c.fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + if simulate_alpha: + cmap.append(Color.layer([c, 'white'], space='srgb').to_string(hex=True, alpha=False)) + else: + cmap.append(c.to_string(hex=True, alpha=False)) + + trace = go.Scatter3d( + x=x, y=y, z=z, + mode = 'markers', + marker={'color': cmap, 'opacity': 1}, + showlegend=False + ) + + fig.add_trace(trace) + + +def plot_harmony( + fig, + space, + harmony, + gmap, + simulate_alpha, + harmony_gmap, + filters=() +): + """Plot color harmony.""" + + if not harmony: + return + + hcolor, options = harmony + if 'space' not in options: + options['space'] = space + options['out_space'] = space + + colors = Color(hcolor).harmony(**options) + + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + cmap = [] + x = [] + y = [] + z = [] + for s in colors: + c = s.normalize(nans=False) + if harmony_gmap: + c.fit('srgb', **gmap) + store_coords(c, x, y, z, flags) + c.convert('srgb', in_place=True).fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + if simulate_alpha: + cmap.append(Color.layer([c, 'white'], space='srgb').to_string(hex=True, alpha=False)) + else: + cmap.append(c.to_string(hex=True, alpha=False)) + + if options['name'] in ('wheel', 'rectangle', 'square', 'triad'): + x.append(x[0]) + y.append(y[0]) + z.append(z[0]) + cmap.append(cmap[0]) + size = ([8] * (len(x) - 1)) + [0] + else: + size = [8] * len(x) + + trace = go.Scatter3d( + x=x, y=y, z=z, + marker={'size': size, 'color': cmap, 'opacity': 1}, + line={'color': 'black', 'width': 3}, + showlegend=False + ) + + fig.add_trace(trace) + + +def plot_average( + fig, + space, + avg_colors, + avg_options, + gmap, + simulate_alpha, + avg_gmap, + filters=() +): + """Plot interpolations.""" + + if not avg_colors: + return + + parts = avg_colors.split(':') + + colors = parts[0].split(';') + if len(parts) == 2: + weights = [float(i.strip()) for i in parts[1].split(',')] + else: + weights = None + + color = Color.average( + colors, + weights, + space=avg_options['space'] + ) + + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + for s in colors: + x = [] + y = [] + z = [] + cmap = [] + c = Color(s).convert(space, in_place=True).normalize(nans=False) + if avg_gmap: + c.fit('srgb', **gmap) + store_coords(c, x, y, z, flags) + c.convert('srgb', in_place=True).fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + if simulate_alpha: + cmap.append(Color.layer([c, 'white'], space='srgb').to_string(hex=True, alpha=False)) + else: + cmap.append(c.to_string(comma=True, alpha=False)) + + c = Color(color).convert(space, in_place=True).normalize(nans=False) + if avg_gmap: + c.fit('srgb', **gmap) + store_coords(c, x, y, z, flags) + c.convert('srgb', in_place=True).fit(**gmap) + if filters: + c.filter(filters[0], **filters[1], in_place=True, out_space=c.space()).clip() + if simulate_alpha: + cmap.append(Color.layer([c, 'white'], space='srgb').to_string(hex=True, alpha=False)) + else: + cmap.append(c.to_string(hex=True, alpha=False)) + + trace = go.Scatter3d( + x=x, y=y, z=z, + marker={'size': [8, 16], 'color': cmap, 'opacity': 1}, + line={'color': cmap[0], 'width': 3}, + showlegend=False + ) + + fig.add_trace(trace) + +def plot_trajectory( + fig, + space, + trajectory_colors, # list[Color] or anything Color() can parse + gmap, + filters=(), + connect_line=True, + marker_size=8, + line_width=3, + opacity=1.0, + simulate_alpha=False +): + # Figure out how to place coords in this `space` + target = Color.CS_MAP[space] + flags = { + 'is_cyl': target.is_polar(), + 'is_labish': isinstance(target, Labish), + 'is_lchish': isinstance(target, LChish), + 'is_hslish': isinstance(target, HSLish), + 'is_hwbish': isinstance(target, HWBish), + 'is_hsvish': isinstance(target, HSVish) + } + + x = [] + y = [] + z = [] + cmap = [] + + for c in trajectory_colors: + c = Color(c) # accept either Color objects or strings + c.convert(space, in_place=True).normalize(nans=False) + + # project to 3D coords in the same way gamut surfaces are plotted + store_coords(c, x, y, z, flags) + + # choose marker fill color: display in sRGB, gamut-mapped + c_disp = c.convert('srgb') + if not c_disp.in_gamut(): + c_disp.fit(**gmap) + else: + c_disp.clip() + if filters: + c_disp.filter(filters[0], **filters[1], in_place=True, out_space=c_disp.space()).clip() + + if simulate_alpha: + cmap.append(Color.layer([c_disp, 'white'], space='srgb').to_string(hex=True, alpha=False)) + else: + cmap.append(c_disp.to_string(hex=True, alpha=False)) + + mode = 'lines+markers' if connect_line else 'markers' + + fig.add_trace( + go.Scatter3d( + x=x, + y=y, + z=z, + opacity=opacity, + mode=mode, + marker={ + 'size': marker_size, + 'color': cmap, + 'opacity': 1, + 'line': {'width': 1, 'color': 'black'} + }, + line={'width': line_width, 'color': 'black'} if connect_line else {'width': 0}, + showlegend=False + ) + ) + + + +def main(): + """Main.""" + + parser = argparse.ArgumentParser(prog='3d_diagrams', description='Plot 3D gamut in a different color spaces.') + parser.add_argument('--space', '-s', help='Desired space.') + + # Gamut and gamut mapping + parser.add_argument( + '--gamut', + '-g', + action='append', + default=[], + help=( + "Gamut space to render space in. Can be followed by a JSON config in the form 'space:{}' to set `edges`," + '`faces`, `opacity`, or `resolution`. `edges` and `faces` can be a boolean to disable or enable them or ' + 'color to configure them all as a specific color.' + ) + ) + parser.add_argument( + '--gmap', + default='raytrace', + help=( + "Gamut mapping algorithm. To set additional options, follow the algorithm with with a JSON string and " + "containing the parameters in the form of 'algorithm:{}'." + ) + ) + parser.add_argument('--gmap-colors', default='', help='Color(s) to gamut map, separated by semicolons.') + parser.add_argument( + '--colors', + default='', + help='Plot arbitrary color points. Colors are separated with semicolons.' + ) + + # Interpolation visualization + parser.add_argument( + '--avg-colors', + default='', + help="Colors that should be averaged together separated by semicolons." + ) + parser.add_argument( + '--average-options', + default='{}', + help=( + "Averaging configuration (JSON string)." + ) + ) + + parser.add_argument('--interp-colors', default='', help='Interpolation colors separated by semicolons.') + parser.add_argument( + '--interp-method', + default='linear', + help=( + "Interpolation configuration. Interpolation method followed by an optional JSON containing options: " + "'method: {}'" + ) + ) + parser.add_argument( + '--harmony', + default='', + help=( + "Harmony configuration: 'color:harmony'. Harmony can be followed by an optional JSON containing options: " + "'color:harmony: {}'" + ) + ) + parser.add_argument( + '--mix-alpha', + action='store_true', + help="Simulate interpolation/averaging/harmony opacity by overlaying on white." + ) + parser.add_argument( + '--mix-gmap', + action='store_true', + help="Force plotted interpolation/averaging/harmony results to be gamut mapped." + ) + + parser.add_argument( + '--filter', + default='', + help=( + "Apply filter. Filter options can be provided as a JSON string after filter name: 'filter:{}'." + ) + ) + + # Graphical and plotting options + parser.add_argument('--title', '-t', default='', help="Provide a title for the diagram.") + parser.add_argument('--dark', action="store_true", help="Use dark theme.") + parser.add_argument('--output', '-o', default='', help='Output file.') + parser.add_argument('--height', '-H', type=int, default=800, help="Height") + parser.add_argument('--width', '-W', type=int, default=800, help="Width") + + # Camera and perspective + parser.add_argument('--pos', '-p', default=None, help="Position of camara 'x:y:z'") + parser.add_argument('--azimuth', '-A', type=float, default=45, help="Camera X position") + parser.add_argument('--elevation', '-E', type=float, default=45, help="Camera Y position") + parser.add_argument('--distance', '-D', type=float, default=2.5, help="Camera Z position") + parser.add_argument( + '--aspect-ratio', '-R', + default='1:1:1', + help="Aspect ratio. Set to 0:0:0 to leave aspect ratio untouched." + ) + parser.add_argument( + '--projection', '-P', + default='perspective', + help="Projection mode, perspective or orthographic" + ) + + args = parser.parse_args() + + gamuts = {} + first = None + for gamut in args.gamut: + parts = [p.strip() if not e else json.loads(p) for e, p in enumerate(gamut.split(':', 1))] + gamuts[parts[0]] = {} if len(parts) == 1 else parts[1] + first = parts[0] + if first is None: + first = 'srgb' + gamuts['srgb'] = {} + + aspect = {k: float(v) for k, v in zip(['x', 'y', 'z'], args.aspect_ratio.split(':'))} + parts = [p.strip() if not e else json.loads(p) for e, p in enumerate(args.gmap.split(':', 1))] + gmap = {'method': parts[0]} + if len(parts) == 2: + gmap.update(parts[1]) + + filters = [] + if args.filter: + parts = [p.strip() if not e else json.loads(p) for e, p in enumerate(args.filter.split(':', 1))] + filters.append(parts[0]) + if len(parts) == 2: + filters.append(parts[1]) + else: + filters.append({}) + + # Plot the color space(s) + fig = plot_gamut_in_space( + args.space, + gamuts, + title=args.title, + dark=args.dark, + gmap=gmap, + size=(args.width, args.height), + camera={'a': args.azimuth, 'e': args.elevation, 'r': args.distance}, + aspect=aspect, + projection=args.projection, + filters=filters + ) + + parts = [p.strip() if not e else json.loads(p) for e, p in enumerate(args.interp_method.split(':', 1))] + interp = {'method': parts[0], 'hue': 'shorter', 'steps': 100} + if len(parts) == 2: + interp.update(parts[1]) + + # Plot interpolation + plot_interpolation( + fig, + args.space, + args.interp_colors, + interp, + gmap, + args.mix_alpha, + args.mix_gmap, + filters + ) + + avg_options = {"space": "srgb-linear"} + avg_options.update(json.loads(args.average_options)) + plot_average( + fig, + args.space, + args.avg_colors, + avg_options, + gmap, + args.mix_alpha, + args.mix_gmap, + filters + ) + + parts = [p.strip() if e < 2 else json.loads(p) for e, p in enumerate(args.harmony.split(':', 2)) if p] + harmony_config = [] + if parts: + hcolor = parts[0] + harmony = {'name': parts[1]} + if len(parts) == 3: + harmony.update(parts[2]) + harmony_config = [hcolor, harmony] + + plot_harmony( + fig, + args.space, + harmony_config, + gmap, + args.mix_alpha, + args.mix_gmap, + filters + ) + + # Plot gamut mapping examples + plot_colors(fig, args.space, first, args.gmap_colors, args.colors, gmap, filters) + + # Show or save the data as an image, etc. + if fig: + if args.output: + filetype = os.path.splitext(args.output)[1].lstrip('.').lower() + if filetype == 'html': + with open(args.output, 'w') as f: + f.write(io.to_html(fig)) + elif filetype == 'json': + io.write_json(fig, args.output) + else: + with open(args.output, 'wb') as f: + f.write(fig.to_image(format=filetype, width=args.width, height=args.height)) + else: + fig.show('browser') + return 0 + return 1 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/notebooks/monobiome_qbr-shapenorm.ipynb b/notebooks/monobiome_qbr-shapenorm.ipynb new file mode 100644 index 0000000..4d07891 --- /dev/null +++ b/notebooks/monobiome_qbr-shapenorm.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e151bcbd-93f2-41ec-8c2d-3666cec26af9", + "metadata": {}, + "source": [ + "**This notebook**: same as the dedicated QBR explorations, but within key lightness ranges (i.e., 45-70), attempt to normalize the accent chroma curves. The idea: there's a consistent order to the *distinction* between accents. Since chroma is the only free parameter at this point that determines perceptual distinction, and *fixing* that chroma is out of the question (leads to dull schemes, on the whole), we'd like the *relative distinction/role* of each accent to remain consistent across lightness values." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cd89e94a-d2f6-4c91-9c27-bdae00378834", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from pathlib import Path\n", + "from functools import cache\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.interpolate import interp1d, CubicSpline, BSpline\n", + "\n", + "from coloraide import Color\n", + "\n", + "@cache\n", + "def max_C_Lh(L, h, space='srgb', eps=1e-6, tol=1e-9):\n", + " '''\n", + " Binary search for max chroma at fixed lightness and hue\n", + "\n", + " Parameters:\n", + " L: lightness percentage\n", + " '''\n", + " def C_in_gamut(C):\n", + " return Color('oklch', [L/100, C, h]).convert(space).in_gamut(tolerance=tol)\n", + "\n", + " lo, hi = 0.0, 0.1\n", + " while C_in_gamut(hi): hi *= 2\n", + " while hi - lo > eps:\n", + " m = (lo + hi) / 2\n", + " lo, hi = (m, hi) if C_in_gamut(m) else (lo, m)\n", + "\n", + " Cmax = lo\n", + " c_oklch = Color('oklch', [L, Cmax, h])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " return Cmax\n", + "\n", + "def quad_bezier_rational(P0, P1, P2, w, t):\n", + " t = np.asarray(t)[:, None]\n", + " num = (1-t)**2*P0 + 2*w*(1-t)*t*P1 + t**2*P2\n", + " den = (1-t)**2 + 2*w*(1-t)*t + t**2\n", + " \n", + " return num/den\n", + " \n", + "def bezier_y_at_x(P0, P1, P2, w, x_query, n=400):\n", + " t = np.linspace(0, 1, n)\n", + " B = quad_bezier_rational(P0, P1, P2, w, t)\n", + " x_vals, y_vals = B[:, 0], B[:, 1]\n", + " \n", + " return np.interp(x_query, x_vals, y_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c7d2d1d9-dad9-4f8f-8417-c22d38f089f0", + "metadata": {}, + "outputs": [], + "source": [ + "# SET LIGHTNESS CONTROL POINTS\n", + "# L_points = [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 98]\n", + "L_points = list(range(10, 98+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b0617a01-cb05-4950-9bc3-f4fd0de63f56", + "metadata": {}, + "outputs": [], + "source": [ + "# FIXED MONOBIOME PARAMETERS\n", + "L_resolution = 5 # step size along lightness dim\n", + "L_space = np.arange(0, 100+L_resolution, L_resolution)\n", + "\n", + "monotone_C_map = {\n", + " \"alpine\": 0,\n", + " \"badlands\": 0.011,\n", + " \"chaparral\": 0.011,\n", + " \"savanna\": 0.011,\n", + " \"grassland\": 0.011,\n", + " \"tundra\": 0.011,\n", + "}\n", + "\n", + "h_weights = {\n", + " \"red\": 3.2,\n", + " \"orange\": 3.8, # 3.6\n", + " \"yellow\": 3.8, # 4.0\n", + " \"green\": 3.8,\n", + " \"blue\": 3.2, # 3.8\n", + "}\n", + "h_L_offsets = {\n", + " \"red\": 1, # -1,\n", + " \"orange\": -8, # -3,\n", + " \"yellow\": -18, # -8\n", + " \"green\": -16, # -8\n", + " \"blue\": 10, # 14\n", + "}\n", + "h_C_offsets = {\n", + " \"red\": -0.01, # 0\n", + " \"orange\": -0.01, # -0.02\n", + " \"yellow\": -0.07, # -0.08\n", + " \"green\": -0.09, # -0.105\n", + " \"blue\": 0.0, # 0.01\n", + "}\n", + "\n", + "monotone_h_map = {\n", + " \"alpine\": 0,\n", + " \"badlands\": 29,\n", + " \"chaparral\": 62.5,\n", + " \"savanna\": 104,\n", + " \"grassland\": 148,\n", + " \"tundra\": 262,\n", + "}\n", + "accent_h_map = {\n", + " \"red\": 29,\n", + " \"orange\": 62.5,\n", + " \"yellow\": 104,\n", + " \"green\": 148,\n", + " \"blue\": 262,\n", + "}\n", + "h_map = {**monotone_h_map, **accent_h_map}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "46b619a1-9118-4576-9100-c1265ccd15f7", + "metadata": {}, + "outputs": [], + "source": [ + "# compute C max values over each point in L space\n", + "h_Lspace_Cmax = {\n", + " h_str: [max_C_Lh(_L, _h) for _L in L_space]\n", + " for h_str, _h in h_map.items()\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0da9d0b5-fa60-4dd7-aa55-0b3c81e503fd", + "metadata": {}, + "outputs": [], + "source": [ + "# compute *unbounded* chroma curves for all hues\n", + "h_L_points_C = {}\n", + "h_ctrl_L_C = {}\n", + "\n", + "for h_str, _h in monotone_h_map.items():\n", + " h_L_points_C[h_str] = np.array([monotone_C_map[h_str]]*len(L_points))\n", + " \n", + "for h_str, _h in accent_h_map.items():\n", + " Lspace_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " # get L value of max chroma; will be a bezier control\n", + " L_Cmax_idx = np.argmax(Lspace_Cmax)\n", + " L_Cmax = L_space[L_Cmax_idx]\n", + "\n", + " # offset control point by any preset x-shift\n", + " L_Cmax += h_L_offsets[h_str]\n", + "\n", + " # and get max C at the L offset\n", + " Cmax = max_C_Lh(L_Cmax, _h)\n", + "\n", + " # set 3 control points; shift by any global linear offest\n", + " C_offset = h_C_offsets.get(h_str, 0)\n", + " \n", + " p_0 = np.array([0, 0])\n", + " p_Cmax = np.array([L_Cmax, Cmax + C_offset])\n", + " p_100 = np.array([100, 0])\n", + " \n", + " B_L_points = bezier_y_at_x(p_0, p_Cmax, p_100, h_weights.get(h_str, 1), L_points)\n", + " h_L_points_C[h_str] = B_L_points\n", + " h_ctrl_L_C[h_str] = np.vstack([p_0, p_Cmax, p_100])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "56fd3826-c2b7-480e-ac42-a72e96c045f4", + "metadata": {}, + "outputs": [], + "source": [ + "# compute full set of final chroma curves; limits every point to in-gamut max\n", + "h_LC_color_map = {}\n", + "h_L_points_Cstar = {}\n", + "\n", + "for h_str, L_points_C in h_L_points_C.items():\n", + " _h = h_map[h_str]\n", + "\n", + " h_L_points_Cstar[h_str] = [\n", + " max(0, min(_C, max_C_Lh(_L, _h)))\n", + " for _L, _C in zip(L_points, L_points_C)\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c257cdb-7cb4-4aed-b1a4-bb560f4848b0", + "metadata": {}, + "outputs": [], + "source": [ + "# put together objects for output formats\n", + "toml_lines = []\n", + "oklch_hL_dict = {}\n", + "\n", + "for h_str, L_points_Cstar in h_L_points_Cstar.items():\n", + " _h = h_map[h_str]\n", + " toml_lines.append(f\"[{h_str}]\")\n", + " oklch_hL_dict[h_str] = {}\n", + " \n", + " for _L, _C in zip(L_points, L_points_Cstar):\n", + " oklch = Color('oklch', [_L/100, _C, _h])\n", + " srgb = oklch.convert('srgb')\n", + " \n", + " hex_str = srgb.to_string(hex=True)\n", + " \n", + " l, c, h = oklch.convert('oklch').coords()\n", + " # oklch_str = oklch.to_string(percent=False)\n", + " oklch_str = f\"oklch({l*100:.1f}% {c:.4f} {h:.1f})\"\n", + " \n", + " toml_lines.append(f'l{_L} = \"{hex_str}\"')\n", + " oklch_hL_dict[h_str][_L] = oklch_str\n", + " \n", + " toml_lines.append(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "281de03a-1ba4-419a-a991-1a9be2a66667", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax_h_map = {}\n", + "fig, axes = plt.subplots(\n", + " len(monotone_h_map),\n", + " 1,\n", + " sharex=True,\n", + " sharey=True,\n", + " figsize=(4, 8)\n", + ")\n", + "\n", + "for i, h_str in enumerate(h_L_points_Cstar):\n", + " _h = h_map[h_str]\n", + " L_points_Cstar = h_L_points_Cstar[h_str]\n", + " L_space_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " if _h not in ax_h_map:\n", + " ax_h_map[_h] = axes[i]\n", + " ax = ax_h_map[_h]\n", + "\n", + " # plot Cmax and Cstar\n", + " ax.plot(L_space, L_space_Cmax, c=\"b\", alpha=0.2)\n", + " ax.plot(L_points, L_points_Cstar, alpha=0.7)\n", + " \n", + " ax.title.set_text(f\"Hue [${_h}$]\")\n", + " \n", + "axes[-1].set_xlabel(\"Lightness (%)\")\n", + "axes[-1].set_xticks([L_points[0], L_points[-1]])\n", + "\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.9)\n", + "\n", + "plt.suptitle(\"$C^*$ curves for hue groups\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b52e351a-fa3c-4d60-877c-75a938b52289", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v111_L_space = list(range(15, 95+1, 5))\n", + "v111_hC_points = {\n", + " \"red\": [0.058, 0.074, 0.092, 0.11, 0.128, 0.147, 0.167, 0.183, 0.193, 0.193, 0.182, 0.164, 0.14, 0.112, 0.081, 0.052, 0.024],\n", + " \"orange\": [0.030, 0.038, 0.046, 0.058, 0.07, 0.084, 0.1, 0.114, 0.125, 0.134, 0.138, 0.136, 0.128, 0.112, 0.092, 0.064, 0.032],\n", + " \"yellow\": [0.02, 0.024, 0.03, 0.036, 0.044, 0.05, 0.06, 0.068, 0.076, 0.082, 0.088, 0.088, 0.086, 0.082, 0.072, 0.058, 0.04],\n", + " \"green\": [0.0401, 0.048, 0.056, 0.064, 0.072, 0.08, 0.09, 0.098, 0.104, 0.108, 0.11, 0.108, 0.102, 0.094, 0.084, 0.072, 0.05],\n", + " \"blue\": [0.06, 0.072, 0.084, 0.096, 0.106, 0.116, 0.124, 0.13, 0.132, 0.128, 0.122, 0.11, 0.096, 0.08, 0.064, 0.044, 0.023],\n", + "}\n", + "\n", + "ax_h_map = {}\n", + "fig, axes = plt.subplots(\n", + " len(monotone_h_map),\n", + " 1,\n", + " sharex=True,\n", + " sharey=True,\n", + " figsize=(5, 10)\n", + ")\n", + "\n", + "for i, h_str in enumerate(h_L_points_Cstar):\n", + " _h = h_map[h_str]\n", + " L_points_Cstar = h_L_points_Cstar[h_str]\n", + " L_space_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " if _h not in ax_h_map:\n", + " ax_h_map[_h] = axes[i]\n", + " ax = ax_h_map[_h]\n", + "\n", + " # plot Cmax and Cstar\n", + " ax.plot(L_space, L_space_Cmax, c=\"b\", alpha=0.2, label='Cmax')\n", + " ax.plot(L_points, L_points_Cstar, alpha=0.7, label='C*')\n", + "\n", + " if h_str in v111_hC_points:\n", + " ax.scatter(v111_L_space, v111_hC_points[h_str], s=4, label='Cv111')\n", + " \n", + " if h_str in h_ctrl_L_C:\n", + " cpts = h_ctrl_L_C[h_str]\n", + " cpt_x, cpt_y = cpts[:, 0], cpts[:, 1]\n", + " h_w = h_weights.get(h_str, 1)\n", + " \n", + " P0, P1, P2 = cpts[0], cpts[1], cpts[2]\n", + " d0 = 2 * h_w * (P1 - P0)\n", + " d2 = 2 * h_w * (P2 - P1)\n", + "\n", + " handle_scale = 0.25\n", + " H0 = P0 + handle_scale * d0\n", + " H2 = P2 - handle_scale * d2\n", + " \n", + " # ax.plot([P0[0], H0[0]], [P0[1], H0[1]], color='tab:blue', lw=1)\n", + " # ax.plot([P2[0], H2[0]], [P2[1], H2[1]], color='tab:orange', lw=1)\n", + " \n", + " ax.plot(cpt_x, cpt_y, '--', color='gray', lw=1, label='Bezier polygon')\n", + " ax.scatter(cpt_x, cpt_y, color='red', zorder=5, s=2, label='Control points')\n", + " \n", + " ax.title.set_text(f\"Hue [${_h}$]\")\n", + " \n", + "axes[-1].set_ylabel(\"Chroma (C)\")\n", + "axes[-1].set_xlabel(\"Lightness (%)\")\n", + "axes[-1].set_xticks([L_points[0], 50, 65, L_points[-1]])\n", + "\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.9)\n", + "\n", + "handles, labels = axes[-1].get_legend_handles_labels()\n", + "unique = dict(zip(labels, handles))\n", + "fig.legend(unique.values(), unique.keys(), loc='lower center', bbox_to_anchor=(0.5, -0.06), ncol=3)\n", + "\n", + "plt.suptitle(\"$C^*$ curves for hue groups + v111 5% lightness\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1e2a1a5a-7724-459a-9a1e-69ab0f421c3b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from numpy import arctan2, degrees\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", + "\n", + "for h_str in h_L_points_Cstar:\n", + " if h_str not in accent_h_map:\n", + " continue\n", + " ax.fill_between(L_points, h_L_points_Cstar[h_str], alpha=0.2, color='grey', label=h_str)\n", + "\n", + " x, y = L_points, h_L_points_Cstar[h_str]\n", + " n = int(0.5*len(x))\n", + " ax.text(x[n], y[n]-0.01, h_str, rotation=10, va='center', ha='left')\n", + " \n", + "ax.set_xlabel(\"Lightness (%)\")\n", + "ax.set_xticks([L_points[0], 45, 50, 55, 60, 65, 70, L_points[-1]])\n", + "plt.suptitle(\"$C^*$ curves (v1.2.0)\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d137161e-1628-4789-b6ff-b82925b989e5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from numpy import arctan2, degrees\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", + "\n", + "for h_str in h_L_points_Cstar:\n", + " if h_str not in accent_h_map:\n", + " continue\n", + " ax.fill_between(v111_L_space, v111_hC_points[h_str], alpha=0.2, color='grey', label=h_str)\n", + "\n", + " x, y = v111_L_space, v111_hC_points[h_str]\n", + " n = int(0.46*len(x))\n", + " ax.text(x[n], y[n]-0.005, h_str, rotation=30, va='center', ha='left')\n", + " \n", + "ax.set_xlabel(\"Lightness (%)\")\n", + "ax.set_xticks([L_points[0], 45, 50, 55, 60, 65, 70, L_points[-1]])\n", + "plt.suptitle(\"$C^*$ curves (v1.1.1)\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d72e7f0b-a1a4-46f1-84fb-752229afafb5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", + "\n", + "for h_str in h_L_points_Cstar:\n", + " if h_str not in accent_h_map:\n", + " continue\n", + " ax.fill_between(L_points, h_L_points_Cstar[h_str], alpha=0.2, color=h_str)\n", + " \n", + " \n", + "ax.set_xlabel(\"Lightness (%)\")\n", + "ax.set_xticks([L_points[0], 45, 50, 55, 60, 65, 70, L_points[-1]])\n", + "ax.set_xlim(45, 70)\n", + "plt.suptitle(\"$C^*$ curves -- mid-range close-up (v1.2.0)\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ef0dd0d9-a267-494f-b9c6-90d9ab0e6564", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[TOML] written\n", + "[JSON] written\n" + ] + } + ], + "source": [ + "# write files -- QBR = \"quadratic bezier rational\"\n", + "PALETTE_DIR = \"palettes\"\n", + "\n", + "toml_content = '\\n'.join(toml_lines)\n", + "with Path(PALETTE_DIR, 'monobiome-vQBRsn.toml').open('w') as f:\n", + " f.write(toml_content)\n", + "print(\"[TOML] written\")\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-vQBRsn-oklch.json').open('w') as f:\n", + " json.dump(oklch_hL_dict, f)\n", + "print(\"[JSON] written\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10295cea-39e1-421d-b523-2eda615b0abd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "monobiome", + "language": "python", + "name": "monobiome" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/monobiome_qbr.ipynb b/notebooks/monobiome_qbr.ipynb new file mode 100644 index 0000000..b84d2dd --- /dev/null +++ b/notebooks/monobiome_qbr.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "71118fae-2b09-44f2-a874-0120854f98e5", + "metadata": {}, + "source": [ + "## Design considerations\n", + "The principle here is to fit a cubic rational bezier determine the chroma curve. We use L-C boundary control points $(0, 0)$, $(100, 0)$, with a single mid-point $(L^*, C_{L^*}^*)$, where $L^*$ is the lightness at which the *maximum, maximum* chroma $C_{L^*}^*$ occurs.\n", + "\n", + "We allow some slight adjustments to this scheme, like shifting the $L^*$ point and changing the weight of the mid-point in the bezier curve (producing sharper, more pointed curves). The general aim is to fit the existing v1.1.1 chroma curves with an explainable continuous model, which of course can be used to generate color points for any reqested lightness levels.\n", + "\n", + "### Future considerations\n", + "I like the idea of the **MCL** scheme, not used here. This scheme used a standardized lightness midpoint where chroma was maximized (for each accent), but did not fix the curve itself. So accent chroma curves had different heights, but they rise and fall in the same places along the lightness spectrum. Each step can be seen to make the *same percentage jump* to the maximum, unifying the movements across accents (e.g., if yellow has max chroma of 0.1 and red of 0.4, the chroma value at lightness L is the same x% of each accent's respective chroma max). This was a step in the right direction compared to **UCC**, which used an *identical* chroma curve for all accents. So while **MCL** preserved more color identity, it still had distinct effects like washing out the orange too early. But I *do* like the idea of being able to have unified justification for the chroma curve jumps across all accents, and while **QBR** (below) is a faithful v111 reproduction, the curves are pretty distinct in terms of shape (due to the allowed weighting; some are sharper, some smoother).\n", + "\n", + "We can also constrain by `Lab` distance: at `L60` or so, we could look at `Lab` distance from the grey `L20` reference background and make sure all accents have the same distance (which is basically just trying to get a uniform contrast ratio). We might also look at `Lab` distance *between* accents and make sure that *relative distinction* is preserved as we move across lightness levels.\n", + "\n", + "TODO: symmetry around 45 -- 60, no matter what. Or decide on new distances, but flipping light/dark should have the same contrast. If that doesn't line up with lightness, so be it; need to find either Lab distance or whatever makes that symmetric." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cd89e94a-d2f6-4c91-9c27-bdae00378834", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from pathlib import Path\n", + "from functools import cache\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.interpolate import interp1d, CubicSpline, BSpline\n", + "\n", + "from coloraide import Color\n", + "\n", + "@cache\n", + "def max_C_Lh(L, h, space='srgb', eps=1e-6, tol=1e-9):\n", + " '''\n", + " Binary search for max chroma at fixed lightness and hue\n", + "\n", + " Parameters:\n", + " L: lightness percentage\n", + " '''\n", + " def C_in_gamut(C):\n", + " return Color('oklch', [L/100, C, h]).convert(space).in_gamut(tolerance=tol)\n", + "\n", + " lo, hi = 0.0, 0.1\n", + " while C_in_gamut(hi): hi *= 2\n", + " while hi - lo > eps:\n", + " m = (lo + hi) / 2\n", + " lo, hi = (m, hi) if C_in_gamut(m) else (lo, m)\n", + "\n", + " Cmax = lo\n", + " c_oklch = Color('oklch', [L, Cmax, h])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " return Cmax\n", + "\n", + "def quad_bezier_rational(P0, P1, P2, w, t):\n", + " t = np.asarray(t)[:, None]\n", + " num = (1-t)**2*P0 + 2*w*(1-t)*t*P1 + t**2*P2\n", + " den = (1-t)**2 + 2*w*(1-t)*t + t**2\n", + " \n", + " return num/den\n", + " \n", + "def bezier_y_at_x(P0, P1, P2, w, x_query, n=400):\n", + " t = np.linspace(0, 1, n)\n", + " B = quad_bezier_rational(P0, P1, P2, w, t)\n", + " x_vals, y_vals = B[:, 0], B[:, 1]\n", + " \n", + " return np.interp(x_query, x_vals, y_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c7d2d1d9-dad9-4f8f-8417-c22d38f089f0", + "metadata": {}, + "outputs": [], + "source": [ + "# SET LIGHTNESS CONTROL POINTS\n", + "# L_points = [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 98]\n", + "L_points = list(range(10, 98+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e7a0fba9-d5e7-4493-8bd5-58d3f7c62304", + "metadata": {}, + "outputs": [], + "source": [ + "# FIXED MONOBIOME PARAMETERS\n", + "L_resolution = 5 # step size along lightness dim\n", + "L_space = np.arange(0, 100+L_resolution, L_resolution)\n", + "\n", + "monotone_C_map = {\n", + " \"alpine\": 0,\n", + " \"badlands\": 0.011,\n", + " \"chaparral\": 0.011,\n", + " \"savanna\": 0.011,\n", + " \"grassland\": 0.011,\n", + " \"tundra\": 0.011,\n", + "}\n", + "\n", + "h_weights = {\n", + " \"red\": 3.5,\n", + " \"orange\": 3.5,\n", + " \"yellow\": 0.7,\n", + " \"green\": 0.95,\n", + " \"blue\": 1.0,\n", + "}\n", + "h_offsets = {\n", + " \"red\": -1, # -5,\n", + " \"orange\": 0, #-2,\n", + " \"yellow\": 0,\n", + " \"green\": 0,\n", + " \"blue\": 0,\n", + "}\n", + "\n", + "monotone_h_map = {\n", + " \"alpine\": 0,\n", + " \"badlands\": 29,\n", + " \"chaparral\": 62.5,\n", + " \"savanna\": 104,\n", + " \"grassland\": 148,\n", + " \"tundra\": 262,\n", + "}\n", + "accent_h_map = {\n", + " \"red\": 29,\n", + " \"orange\": 62.5,\n", + " \"yellow\": 104,\n", + " \"green\": 148,\n", + " \"blue\": 262,\n", + "}\n", + "h_map = {**monotone_h_map, **accent_h_map}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "46b619a1-9118-4576-9100-c1265ccd15f7", + "metadata": {}, + "outputs": [], + "source": [ + "# compute C max values over each point in L space\n", + "h_Lspace_Cmax = {\n", + " h_str: [max_C_Lh(_L, _h) for _L in L_space]\n", + " for h_str, _h in h_map.items()\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0da9d0b5-fa60-4dd7-aa55-0b3c81e503fd", + "metadata": {}, + "outputs": [], + "source": [ + "# compute *unbounded* chroma curves for all hues\n", + "h_L_points_C = {}\n", + "h_ctrl_L_C = {}\n", + "\n", + "for h_str, _h in monotone_h_map.items():\n", + " h_L_points_C[h_str] = [monotone_C_map[h_str]]*len(L_points)\n", + " \n", + "for h_str, _h in accent_h_map.items():\n", + " Lspace_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " # get L value of max chroma; will be a bezier control\n", + " L_Cmax_idx = np.argmax(Lspace_Cmax)\n", + " L_Cmax = L_space[L_Cmax_idx]\n", + "\n", + " # offset control point by any preset x-shift\n", + " L_Cmax += h_offsets[h_str]\n", + "\n", + " # and get max C at the L offset\n", + " Cmax = max_C_Lh(L_Cmax, _h)\n", + "\n", + " # set 3 control points\n", + " p_0 = np.array([0, 0])\n", + " p_Cmax = np.array([L_Cmax, Cmax])\n", + " p_100 = np.array([100, 0])\n", + " \n", + " B_L_points = bezier_y_at_x(p_0, p_Cmax, p_100, h_weights.get(h_str, 1), L_points)\n", + " h_L_points_C[h_str] = B_L_points\n", + " h_ctrl_L_C[h_str] = np.vstack([p_0, p_Cmax, p_100])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "56fd3826-c2b7-480e-ac42-a72e96c045f4", + "metadata": {}, + "outputs": [], + "source": [ + "# compute full set of final chroma curves\n", + "h_LC_color_map = {}\n", + "h_L_points_Cstar = {}\n", + "\n", + "for h_str, L_points_C in h_L_points_C.items():\n", + " _h = h_map[h_str]\n", + " h_L_points_Cstar[h_str] = [\n", + " min(_C, max_C_Lh(_L, _h))\n", + " for _L, _C in zip(L_points, L_points_C)\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3c257cdb-7cb4-4aed-b1a4-bb560f4848b0", + "metadata": {}, + "outputs": [], + "source": [ + "# put together objects for output formats\n", + "toml_lines = []\n", + "oklch_hL_dict = {}\n", + "\n", + "for h_str, L_points_Cstar in h_L_points_Cstar.items():\n", + " _h = h_map[h_str]\n", + " toml_lines.append(f\"[{h_str}]\")\n", + " oklch_hL_dict[h_str] = {}\n", + " \n", + " for _L, _C in zip(L_points, L_points_Cstar):\n", + " oklch = Color('oklch', [_L/100, _C, _h])\n", + " srgb = oklch.convert('srgb')\n", + " \n", + " hex_str = srgb.to_string(hex=True)\n", + " oklch_str = oklch.to_string(percent=False)\n", + " \n", + " toml_lines.append(f'l{_L} = \"{hex_str}\"')\n", + " oklch_hL_dict[h_str][_L] = oklch_str\n", + " \n", + " toml_lines.append(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "281de03a-1ba4-419a-a991-1a9be2a66667", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax_h_map = {}\n", + "fig, axes = plt.subplots(\n", + " len(monotone_h_map),\n", + " 1,\n", + " sharex=True,\n", + " sharey=True,\n", + " figsize=(4, 8)\n", + ")\n", + "\n", + "for i, h_str in enumerate(h_L_points_Cstar):\n", + " _h = h_map[h_str]\n", + " L_points_Cstar = h_L_points_Cstar[h_str]\n", + " L_space_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " if _h not in ax_h_map:\n", + " ax_h_map[_h] = axes[i]\n", + " ax = ax_h_map[_h]\n", + "\n", + " # plot Cmax and Cstar\n", + " ax.plot(L_space, L_space_Cmax, c=\"b\", alpha=0.2)\n", + " ax.plot(L_points, L_points_Cstar, alpha=0.7)\n", + " \n", + " ax.title.set_text(f\"Hue [${_h}$]\")\n", + " \n", + "axes[-1].set_xlabel(\"Lightness (%)\")\n", + "axes[-1].set_xticks([L_points[0], L_points[-1]])\n", + "\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.9)\n", + "\n", + "plt.suptitle(\"$C^*$ curves for hue groups\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b52e351a-fa3c-4d60-877c-75a938b52289", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v111_L_space = list(range(15, 95+1, 5))\n", + "v111_hC_points = {\n", + " \"red\": [0.058, 0.074, 0.092, 0.11, 0.128, 0.147, 0.167, 0.183, 0.193, 0.193, 0.182, 0.164, 0.14, 0.112, 0.081, 0.052, 0.024],\n", + " \"orange\": [0.030, 0.038, 0.046, 0.058, 0.07, 0.084, 0.1, 0.114, 0.125, 0.134, 0.138, 0.136, 0.128, 0.112, 0.092, 0.064, 0.032],\n", + " \"yellow\": [0.02, 0.024, 0.03, 0.036, 0.044, 0.05, 0.06, 0.068, 0.076, 0.082, 0.088, 0.088, 0.086, 0.082, 0.072, 0.058, 0.04],\n", + " \"green\": [0.0401, 0.048, 0.056, 0.064, 0.072, 0.08, 0.09, 0.098, 0.104, 0.108, 0.11, 0.108, 0.102, 0.094, 0.084, 0.072, 0.05],\n", + " \"blue\": [0.06, 0.072, 0.084, 0.096, 0.106, 0.116, 0.124, 0.13, 0.132, 0.128, 0.122, 0.11, 0.096, 0.08, 0.064, 0.044, 0.023],\n", + "}\n", + "\n", + "ax_h_map = {}\n", + "fig, axes = plt.subplots(\n", + " len(monotone_h_map),\n", + " 1,\n", + " sharex=True,\n", + " sharey=True,\n", + " figsize=(6, 10)\n", + ")\n", + "\n", + "for i, h_str in enumerate(h_L_points_Cstar):\n", + " _h = h_map[h_str]\n", + " L_points_Cstar = h_L_points_Cstar[h_str]\n", + " L_space_Cmax = h_Lspace_Cmax[h_str]\n", + " \n", + " if _h not in ax_h_map:\n", + " ax_h_map[_h] = axes[i]\n", + " ax = ax_h_map[_h]\n", + "\n", + " # plot Cmax and Cstar\n", + " ax.plot(L_space, L_space_Cmax, c=\"b\", alpha=0.2)\n", + " ax.plot(L_points, L_points_Cstar, alpha=0.7)\n", + "\n", + " if h_str in v111_hC_points:\n", + " ax.scatter(v111_L_space, v111_hC_points[h_str], s=4)\n", + " \n", + " if h_str in h_ctrl_L_C:\n", + " cpts = h_ctrl_L_C[h_str]\n", + " cpt_x, cpt_y = cpts[:, 0], cpts[:, 1]\n", + " h_w = h_weights.get(h_str, 1)\n", + " \n", + " P0, P1, P2 = cpts[0], cpts[1], cpts[2]\n", + " d0 = 2 * h_w * (P1 - P0)\n", + " d2 = 2 * h_w * (P2 - P1)\n", + "\n", + " handle_scale = 0.25\n", + " H0 = P0 + handle_scale * d0\n", + " H2 = P2 - handle_scale * d2\n", + " \n", + " # ax.plot([P0[0], H0[0]], [P0[1], H0[1]], color='tab:blue', lw=1)\n", + " # ax.plot([P2[0], H2[0]], [P2[1], H2[1]], color='tab:orange', lw=1)\n", + " \n", + " ax.plot(cpt_x, cpt_y, '--', color='gray', lw=1, label='control polygon')\n", + " ax.scatter(cpt_x, cpt_y, color='red', zorder=5, s=2)\n", + " \n", + " ax.title.set_text(f\"Hue [${_h}$]\")\n", + " \n", + "axes[-1].set_xlabel(\"Lightness (%)\")\n", + "axes[-1].set_xticks([L_points[0], 50, 65, L_points[-1]])\n", + "\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.9)\n", + "\n", + "plt.suptitle(\"$C^*$ curves for hue groups + v111 5% lightness\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1e2a1a5a-7724-459a-9a1e-69ab0f421c3b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", + "\n", + "for h_str in h_L_points_Cstar:\n", + " if h_str not in accent_h_map:\n", + " continue\n", + " ax.fill_between(L_points, h_L_points_Cstar[h_str], alpha=0.5, color=h_str)\n", + " \n", + "ax.set_xlabel(\"Lightness (%)\")\n", + "ax.set_xticks([L_points[0], 45, 50, 55, 60, 65, 70, L_points[-1]])\n", + "ax.set_xlim(45, 70)\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ef0dd0d9-a267-494f-b9c6-90d9ab0e6564", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[TOML] written\n", + "[JSON] written\n" + ] + } + ], + "source": [ + "# write files -- QBR = \"quadratic bezier rational\"\n", + "PALETTE_DIR = \"palettes\"\n", + "\n", + "toml_content = '\\n'.join(toml_lines)\n", + "with Path(PALETTE_DIR, 'monobiome-vQBR.toml').open('w') as f:\n", + " f.write(toml_content)\n", + "print(\"[TOML] written\")\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-vQBR-oklch.json').open('w') as f:\n", + " json.dump(oklch_hL_dict, f)\n", + "print(\"[JSON] written\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10295cea-39e1-421d-b523-2eda615b0abd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "monobiome", + "language": "python", + "name": "monobiome" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/palette.ipynb b/notebooks/palette.ipynb new file mode 100644 index 0000000..a2b5763 --- /dev/null +++ b/notebooks/palette.ipynb @@ -0,0 +1,1023 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5919980c-2b7c-4e17-8ce8-a64bc71d6ce1", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.interpolate import interp1d, CubicSpline, BSpline\n", + "\n", + "from coloraide import Color" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a8c22978-bef8-42ae-a058-501679c5b1fd", + "metadata": {}, + "outputs": [], + "source": [ + "def max_chroma_fixed_LH(L, h, space='srgb', eps=1e-6, tol=1e-9):\n", + " def ok(C):\n", + " # build the exact OKLCH with fixed L,h; check if it lies in target gamut\n", + " return Color('oklch', [L, C, h]).convert(space).in_gamut(tolerance=tol)\n", + "\n", + " lo, hi = 0.0, 0.1\n", + " while ok(hi): hi *= 2\n", + " while hi - lo > eps:\n", + " m = (lo + hi) / 2\n", + " lo, hi = (m, hi) if ok(m) else (lo, m)\n", + "\n", + " Cmax = lo\n", + " c_oklch = Color('oklch', [L, Cmax, h])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " return Cmax, c_oklch, c_srgb.to_string(hex=True)\n", + " \n", + "# weighted bezier; larger `w` to bring the curve to the corner point P1\n", + "def quad_bezier_rational(P0, P1, P2, w, t):\n", + " t = np.asarray(t)[:,None]\n", + " num = (1-t)**2*P0 + 2*w*(1-t)*t*P1 + t**2*P2\n", + " den = (1-t)**2 + 2*w*(1-t)*t + t**2\n", + " return num/den\n", + " \n", + "def bezier_y_at_x(P0, P1, P2, w, x_query, n=400):\n", + " t = np.linspace(0, 1, n)\n", + " B = quad_bezier_rational(P0, P1, P2, w, t)\n", + " x_vals, y_vals = B[:, 0], B[:, 1]\n", + " return np.interp(x_query, x_vals, y_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d7c619e5-71e8-46e0-8c7c-b0de28d999aa", + "metadata": {}, + "outputs": [], + "source": [ + "PALETTE_DIR = \"palettes\"\n", + "\n", + "# lightness_levels_n1 = list(range(15, 95+1, 1))\n", + "lightness_levels_n1 = list(range(0, 100+1, 1))\n", + "lightness_levels_n5 = list(range(15, 95+1, 5))\n", + "\n", + "monotone_hue_map = {\n", + " \"alpine\": 0,\n", + " \"badlands\": 29,\n", + " \"chaparral\": 62.5,\n", + " \"savanna\": 104,\n", + " \"grassland\": 148,\n", + " \"tundra\": 262,\n", + "}\n", + "accent_hue_map = {\n", + " \"red\": 29,\n", + " \"orange\": 62.5,\n", + " \"yellow\": 104,\n", + " \"green\": 148,\n", + " \"blue\": 262,\n", + "}\n", + "hue_map = {**monotone_hue_map, **accent_hue_map}\n", + "\n", + "# existing chroma settings at 5% lightness increments (v1.1.1)\n", + "mb_chroma_pts = {\n", + " \"red\": [0.058, 0.074, 0.092, 0.11, 0.128, 0.147, 0.167, 0.183, 0.193, 0.193, 0.182, 0.164, 0.14, 0.112, 0.081, 0.052, 0.024],\n", + " \"orange\": [0.030, 0.038, 0.046, 0.058, 0.07, 0.084, 0.1, 0.114, 0.125, 0.134, 0.138, 0.136, 0.128, 0.112, 0.092, 0.064, 0.032],\n", + " \"yellow\": [0.02, 0.024, 0.03, 0.036, 0.044, 0.05, 0.06, 0.068, 0.076, 0.082, 0.088, 0.088, 0.086, 0.082, 0.072, 0.058, 0.04],\n", + " \"green\": [0.0401, 0.048, 0.056, 0.064, 0.072, 0.08, 0.09, 0.098, 0.104, 0.108, 0.11, 0.108, 0.102, 0.094, 0.084, 0.072, 0.05],\n", + " \"blue\": [0.06, 0.072, 0.084, 0.096, 0.106, 0.116, 0.124, 0.13, 0.132, 0.128, 0.122, 0.11, 0.096, 0.08, 0.064, 0.044, 0.023],\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "a3d28771-c144-474b-8fa8-f6859ef8ce05", + "metadata": {}, + "source": [ + "### Max chroma bounds and interpolated curves (v1.1.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3e5bcb42-c0a6-49b3-8350-67aec5bb391e", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# max chroma bounds\n", + "hue_cmax_map = {}\n", + "for hue_key, hue_val in hue_map.items():\n", + " hue_cmax_map[hue_key] = []\n", + " for ll in lightness_levels_n1:\n", + " max_chroma = max_chroma_fixed_LH(ll/100, hue_val)[0]\n", + " hue_cmax_map[hue_key].append(max_chroma)\n", + "\n", + "# interpolated chroma levels\n", + "hue_cinterp_lin_map = {}\n", + "hue_cinterp_cub_map = {}\n", + "for hue_key, hue_val in accent_hue_map.items():\n", + " x1 = np.array(lightness_levels_n1)\n", + " x5 = np.array(lightness_levels_n5)\n", + " y5 = np.array(mb_chroma_pts[hue_key])\n", + "\n", + " y1 = np.interp(x1, x5, y5)\n", + " hue_cinterp_lin_map[hue_key] = y1\n", + " \n", + " f = interp1d(x5, y5, kind='quadratic', fill_value='extrapolate')\n", + " f = CubicSpline(x5, y5, bc_type='natural')\n", + " hue_cinterp_cub_map[hue_key] = f(x1)\n", + "\n", + " # use just: start, end, and max\n", + " max_idx = np.argmax(y5)\n", + " f = CubicSpline(\n", + " [x5[0], x5[1], x5[max_idx-1], x5[max_idx+1], x5[-2], x5[-1]],\n", + " [y5[0], y5[1], y5[max_idx-1], y5[max_idx+1], y5[-2], y5[-1]],\n", + " bc_type='natural'\n", + " )\n", + " hue_cinterp_cub_map[hue_key] = f(x1)\n", + "\n", + "# stacked plots for accents\n", + "fig, axes = plt.subplots(len(accent_hue_map), 1, sharex=True, sharey=True, figsize=(6, 12))\n", + "for ax, hue_label in zip(axes, accent_hue_map):\n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_label])\n", + " ax.plot(lightness_levels_n5, mb_chroma_pts[hue_label])\n", + " \n", + " #ax.plot(lightness_levels_n1, hue_cinterp_lin_map[hue_label])\n", + " ax.plot(lightness_levels_n1, hue_cinterp_cub_map[hue_label], c='g', alpha=0.3)\n", + "\n", + " max_idx = np.argmax(mb_chroma_pts[hue_label])\n", + " spline_indices = [0, 1, max_idx-1, max_idx+1, -2, -1]\n", + " \n", + " ax.scatter(\n", + " np.array(lightness_levels_n5)[spline_indices],\n", + " np.array(mb_chroma_pts[hue_label])[spline_indices],\n", + " c='g'\n", + " )\n", + " \n", + " ax.grid(True, alpha=0.3)\n", + " ax.text(1.01, 0.5, hue_label, transform=ax.transAxes, va='center')\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Max chroma at different lightness levels w/in sRGB gamut\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "32059ed7-7ade-42e5-b2d3-05801d6093f0", + "metadata": {}, + "outputs": [], + "source": [ + "monotone_chroma = 0.011 # fixed monotone chroma\n", + "hl_hex_arr = []\n", + "hl_oklch_map = {}\n", + "hl_hex_map = {}\n", + "\n", + "for i, (hue_name, hue) in enumerate(hue_map.items()):\n", + " lo_map, lh_map = {}, {}\n", + " hl_hex_arr.append(f\"[{hue_name}]\")\n", + " chroma_n1 = hue_cinterp_cub_map.get(hue_name)\n", + " for j, lightness in enumerate(lightness_levels_n1):\n", + " if i == 0:\n", + " chroma = 0\n", + " elif i <= 5:\n", + " chroma = monotone_chroma\n", + " else:\n", + " chroma = chroma_n1[j]\n", + " \n", + " c_oklch = Color('oklch', [lightness/100, chroma, hue])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " oklch_str = c_oklch.to_string(percent=True)\n", + " hex_str = c_srgb.to_string(hex=True)\n", + " \n", + " lo_map[f\"l{lightness}\"] = oklch_str\n", + " lh_map[f\"l{lightness}\"] = hex_str\n", + " hl_hex_arr.append(f'l{lightness} = \"{hex_str}\"')\n", + "\n", + " hl_oklch_map[hue_name] = lo_map\n", + " hl_hex_map[hue_name] = lh_map\n", + " hl_hex_arr.append(\"\")\n", + "\n", + "# write files\n", + "toml_hex = '\\n'.join(hl_hex_arr)\n", + "with Path(PALETTE_DIR, 'monobiome-v111.toml').open('w') as f:\n", + " f.write(toml_hex)\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-v111-oklch.json').open('w') as f:\n", + " json.dump(hl_oklch_map, f)" + ] + }, + { + "cell_type": "markdown", + "id": "a0d65c67-997d-4941-8bca-dce36e839b0e", + "metadata": {}, + "source": [ + "### Attempt to design unified chroma curve for all accents\n", + "After full exploration: nice to have this option, but unifying the chroma curve for all accents mutes their unique qualities. I think it's better to flesh out curves that fully leverage their chroma depths; can maybe standardize the start and end chromas but that's all. Perhaps there's some curve quality that can be applied broadly, but even that can be a bit rough." + ] + }, + { + "cell_type": "markdown", + "id": "1832bc77-6e5d-4b70-a268-46405a5deb2d", + "metadata": {}, + "source": [ + "#### Estimate intersection point" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3c466cbe-236c-41f1-864d-7c2dbc65ef21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.00098114 0.0040535 0.00518646 0. ]\n", + "[0.00050583 0.00410004 0.00483475 0. ]\n", + "[0.00029984 0.00229111 0.00628815 0. ]\n", + "[0.00028915 0.00211182 0.03240891 0. ]\n", + "[0.00058517 0.00289383 0.01599808 0. ]\n", + "[0.0004776 0.0046257 0.00466537 0. ]\n", + "[0.00050583 0.00410004 0.00483475 0. ]\n", + "[0.00029984 0.00229111 0.00628815 0. ]\n", + "[0.00028915 0.00211182 0.03240891 0. ]\n", + "[0.00058517 0.00289383 0.01599808 0. ]\n", + "[0.0004776 0.0046257 0.00466537 0. ]\n", + "\n", + "yellow [0.10558548 0.1076973 0.10980911 0.11192093 0.11403275 0.1161438\n", + " 0.11825562 0.12036743 0.12247925 0.12459106]\n", + "blue [0.23125534 0.23588028 0.24050522 0.24513092 0.24975586 0.24896698\n", + " 0.24254303 0.23615799 0.22981262 0.22350693]\n" + ] + } + ], + "source": [ + "indices = [0, 1, -2, -1]\n", + "for hue in hue_cmax_map:\n", + " print( np.array(np.array(hue_cmax_map[hue])[indices]) )\n", + "print()\n", + "\n", + "# min values after checking 0, 1, -2, -1; then eyeballing l70 and l45\n", + "indices = [ 0, 1, 30, 55, -2, -1]\n", + "values = [0.0315, 0.0337, 0.0900, 0.1250, 0.0285, 0.0236]\n", + "\n", + "# take a look at yellow & blue, the two bottom bounding lines\n", + "print( 'yellow', np.array(hue_cmax_map[\"yellow\"])[50:60] )\n", + "print( 'blue', np.array(hue_cmax_map[\"blue\"])[50:60] )\n", + "# so near guess at that max point is (71, 0.15); see the intersection\n", + "# point below. This is eyeballed to see where Y & B values cross" + ] + }, + { + "cell_type": "markdown", + "id": "496b8585-12d7-49d4-9bcf-ccb70c88242d", + "metadata": {}, + "source": [ + "#### Verify best \"pushed up\" unified chroma curve" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b3a67cae-1ea8-4587-a403-670e22a8e0b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the 3 points to shape the bezier\n", + "indices = [ 15, 71, 95]\n", + "values = [0.0315, 0.1500, 0.0236]\n", + "\n", + "P0 = np.array([indices[0], values[0]])\n", + "P1 = np.array([indices[1], values[1]])\n", + "P2 = np.array([indices[2], values[2]])\n", + "\n", + "t = np.linspace(0, 1, len(lightness_levels_n1)+1)[:, None]\n", + "B = quad_bezier_rational(P0, P1, P2, w=5.0, t=t)\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 3))\n", + "for hue_label in accent_hue_map:\n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_label], c='g', alpha=0.3)\n", + "\n", + "# B is 2D, curve is parametrized; first dim are transformed `t` points\n", + "ax.plot(B[:,:,0], B[:,:,1]) \n", + "\n", + "ax.set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Best chroma bezier under all accent chroma roofs\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.9)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a798c10a-e67a-409e-a3ed-4420df6728cb", + "metadata": {}, + "source": [ + "#### Put together unified chroma & generate color strings" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f3365e1d-bb8d-4b54-8253-4b318d174909", + "metadata": {}, + "outputs": [], + "source": [ + "# calculate curve at exact lightness; counter the bezier reparameterization\n", + "shared_max_chroma_n1 = bezier_y_at_x(P0, P1, P2, 5.0, lightness_levels_n1)\n", + "\n", + "monotone_chroma = 0.011 # fixed monotone chroma\n", + "hl_hex_arr = []\n", + "hl_oklch_map = {}\n", + "hl_hex_map = {}\n", + "\n", + "for i, (hue_name, hue) in enumerate(hue_map.items()):\n", + " lo_map, lh_map = {}, {}\n", + " hl_hex_arr.append(f\"[{hue_name}]\")\n", + " for j, lightness in enumerate(lightness_levels_n1):\n", + " if i == 0:\n", + " chroma = 0\n", + " elif i <= 5:\n", + " chroma = monotone_chroma\n", + " else:\n", + " chroma = shared_max_chroma_n1[j]\n", + " \n", + " c_oklch = Color('oklch', [lightness/100, chroma, hue])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " # oklch_str = c_oklch.to_string(percent=True)\n", + " l, c, h = c_oklch.convert('oklch').coords()\n", + " oklch_str = f\"oklch({l*100:.1f}% {c:.4f} {h:.1f})\"\n", + " \n", + " hex_str = c_srgb.to_string(hex=True)\n", + " \n", + " lo_map[f\"l{lightness}\"] = oklch_str\n", + " lh_map[f\"l{lightness}\"] = hex_str\n", + " hl_hex_arr.append(f'l{lightness} = \"{hex_str}\"')\n", + "\n", + " hl_oklch_map[hue_name] = lo_map\n", + " hl_hex_map[hue_name] = lh_map\n", + " hl_hex_arr.append(\"\")\n", + "\n", + "# write files -- UCC = \"unified chroma curve\"\n", + "toml_hex = '\\n'.join(hl_hex_arr)\n", + "with Path(PALETTE_DIR, 'monobiome-vUCC.toml').open('w') as f:\n", + " f.write(toml_hex)\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-vUCC-oklch.json').open('w') as f:\n", + " json.dump(hl_oklch_map, f)" + ] + }, + { + "cell_type": "markdown", + "id": "ef58a343-2c93-46aa-accc-1590381e8e66", + "metadata": {}, + "source": [ + "### Tailored chroma curves" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "a4d02bc3-44ab-4f62-82cc-4e72cac0a449", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# indices = [ 15, 95]\n", + "# values = [0.0315, 0.0236]\n", + "indices = [0, 100]\n", + "values = [0, 0]\n", + "\n", + "# not the same chroma value, but sync *when* the max chroma is hit\n", + "# so similar curves but allowed to shift up and down\n", + "unified_cx = 55\n", + "unified_cy = [0.22, 0.125, 0.1, 0.13, 0.16]\n", + "\n", + "hue_cinterp_cub_map_unify = {}\n", + "hue_cinterp_cub_map_unify_B = {}\n", + "for i, (hue_key, hue_val) in enumerate(accent_hue_map.items()):\n", + " x1 = np.array(lightness_levels_n1)\n", + " x5 = np.array(lightness_levels_n5)\n", + " y5 = np.array(mb_chroma_pts[hue_key])\n", + "\n", + " max_idx = np.argmax(y5)\n", + " # 2-point middle\n", + " # f = CubicSpline(\n", + " # [indices[0], x5[max_idx-1], x5[max_idx+1], indices[-1]],\n", + " # [values[0], y5[max_idx-1], y5[max_idx+1], values[-1]],\n", + " # bc_type='natural'\n", + " # )\n", + " # 1-point middle\n", + " # f = CubicSpline(\n", + " # [indices[0], x5[max_idx], indices[-1]],\n", + " # [values[0], y5[max_idx], values[-1]],\n", + " # bc_type='natural'\n", + " # )\n", + " f = CubicSpline(\n", + " [indices[0], unified_cx, indices[-1]],\n", + " [values[0], unified_cy[i], values[-1]],\n", + " bc_type='natural'\n", + " )\n", + " # hue_cinterp_cub_map_unify[hue_key] = f(x1)\n", + " \n", + " P0 = np.array([indices[0], values[0]])\n", + " # P1 = np.array([x5[max_idx], y5[max_idx]])\n", + " P1 = np.array([unified_cx, unified_cy[i]])\n", + " P2 = np.array([indices[-1], values[-1]])\n", + " \n", + " t = np.linspace(0, 1, 400)[:, None]\n", + " B = quad_bezier_rational(P0, P1, P2, w=8.0, t=t)\n", + " hue_cinterp_cub_map_unify[hue_key] = B[:,:,1].flatten()\n", + " hue_cinterp_cub_map_unify_B[hue_key] = B\n", + "\n", + "fig, axes = plt.subplots(len(hue_cmax_map), 1, sharex=True, sharey=True, figsize=(6, 10))\n", + "for ax, hue_key in zip(axes, accent_hue_map):\n", + " ax.grid(True, alpha=0.3)\n", + " ax.text(1.01, 0.5, hue_key, transform=ax.transAxes, va='center')\n", + " \n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_key])\n", + " ax.plot(lightness_levels_n1, hue_cinterp_cub_map[hue_key], c='g', alpha=0.5)\n", + " # ax.plot(lightness_levels_n1, hue_cinterp_cub_map_unify[hue_key], c='b', alpha=0.4)\n", + " ax.plot(hue_cinterp_cub_map_unify_B[hue_key][:,:,0], hue_cinterp_cub_map_unify_B[hue_key][:,:,1], c='b', alpha=0.4)\n", + " ax.plot(lightness_levels_n5, mb_chroma_pts[hue_key], c='r', alpha=0.3)\n", + "\n", + " max_idx = np.argmax(mb_chroma_pts[hue_key])\n", + " spline_indices = [0, max_idx-1, max_idx+1, -1]\n", + " \n", + " ax.scatter(\n", + " np.array(lightness_levels_n5)[spline_indices],\n", + " np.array(mb_chroma_pts[hue_key])[spline_indices],\n", + " c='g'\n", + " )\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Max chroma at different lightness levels w/in sRGB gamut\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "daefddbc-2cda-45dd-b2cf-8311732f8ba9", + "metadata": {}, + "outputs": [], + "source": [ + "indices = [ 15, 95]\n", + "values = [0.0315, 0.0236]\n", + "\n", + "# not the same chroma value, but sync *when* the max chroma is hit\n", + "# so similar curves but allowed to shift up and down across hue\n", + "unified_cx = 55\n", + "unified_cy = [0.21, 0.13, 0.09, 0.13, 0.15] # these were manually adjusted\n", + "hue_max_chroma_n1_map = {}\n", + "for i, (hue_key, hue_val) in enumerate(accent_hue_map.items()):\n", + " P0 = np.array([indices[0], values[0]])\n", + " # P1 = np.array([x5[max_idx], y5[max_idx]])\n", + " P1 = np.array([unified_cx, unified_cy[i]])\n", + " P2 = np.array([indices[-1], values[-1]])\n", + " \n", + " t = np.linspace(0, 1, 400)[:, None]\n", + " hue_max_chroma_n1_map[hue_key] = bezier_y_at_x(P0, P1, P2, 5.0, lightness_levels_n1)\n", + " \n", + "monotone_chroma = 0.011 # fixed monotone chroma\n", + "hl_hex_arr = []\n", + "hl_oklch_map = {}\n", + "hl_hex_map = {}\n", + "\n", + "for i, (hue_name, hue) in enumerate(hue_map.items()):\n", + " lo_map, lh_map = {}, {}\n", + " hl_hex_arr.append(f\"[{hue_name}]\")\n", + " max_chroma_n1 = hue_max_chroma_n1_map.get(hue_name)\n", + " for j, lightness in enumerate(lightness_levels_n1):\n", + " if i == 0:\n", + " chroma = 0\n", + " elif i <= 5:\n", + " chroma = monotone_chroma\n", + " else:\n", + " chroma = max_chroma_n1[j]\n", + " \n", + " c_oklch = Color('oklch', [lightness/100, chroma, hue])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " oklch_str = c_oklch.to_string(percent=True)\n", + " hex_str = c_srgb.to_string(hex=True)\n", + " \n", + " lo_map[f\"l{lightness}\"] = oklch_str\n", + " lh_map[f\"l{lightness}\"] = hex_str\n", + " hl_hex_arr.append(f'l{lightness} = \"{hex_str}\"')\n", + "\n", + " hl_oklch_map[hue_name] = lo_map\n", + " hl_hex_map[hue_name] = lh_map\n", + " hl_hex_arr.append(\"\")\n", + "\n", + "# write files -- MCL = \"max chroma lightness\"\n", + "toml_hex = '\\n'.join(hl_hex_arr)\n", + "with Path(PALETTE_DIR, 'monobiome-vMCL.toml').open('w') as f:\n", + " f.write(toml_hex)\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-vMCL-oklch.json').open('w') as f:\n", + " json.dump(hl_oklch_map, f)" + ] + }, + { + "cell_type": "markdown", + "id": "b7cf22fc-5287-4895-8dab-5b9fe0ffa2c6", + "metadata": {}, + "source": [ + "#### Verify the written colors" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "83456bc7-c8c4-4377-a4ef-1dd5e150bb67", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(len(hue_cmax_map), 1, sharex=True, sharey=True, figsize=(4, 4))\n", + "for ax, hue_label in zip(axes, accent_hue_map):\n", + " chroma_list = [\n", + " Color(oklch_str)._coords[1]\n", + " for l_str, oklch_str in hl_oklch_map[hue_label].items()\n", + " ]\n", + " \n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_label], c='b')\n", + " ax.plot(lightness_levels_n1, chroma_list, c='g', alpha=0.7)\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Written chroma levels\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8721f417-c6c2-43eb-bccc-5eed9bdc0c73", + "metadata": {}, + "outputs": [], + "source": [ + "# preview palette\n", + "\n", + "# fig, axes = plt.subplots(len(hue_cmax_map), 1, sharex=True, sharey=True, figsize=(4, 4))\n", + "# for ax, hue_label in zip(axes, accent_hue_map):\n", + "# for l_str, oklch_str in hl_oklch_map[hue_label].items():\n", + "# Color(oklch_str)" + ] + }, + { + "cell_type": "markdown", + "id": "a7b17777-d92f-4541-8627-715b32a21c40", + "metadata": {}, + "source": [ + "#### 3-point quadratic bezier fit to v1.1.1\n", + "The more \"systematic\" design choices for picking chroma curves seem to stamp on accent identifies, even the fixed lightness point (but allowing variable chroma).\n", + "\n", + "Linear or cubic interpolation of the original 5% lightness jumps is acceptable, but I want two things in the new rev:\n", + "\n", + "1. Fixed chroma settings at the beginning (15) and end (95) lightness settings for each accent. This at least gives us some unified bounds for filling in the chroma curve, even if the shapes and control points of the curves vary quite a bit to make the color identities fit as intended.\n", + "2. Follow a parameterized curve rather than being ad hoc, discrete jumps. The previously chosen chroma changes across 5% lightness jumps were something close to linear interpolation between established control points, but they were not reporoducible. That is, it was based on some loose napkin math rather than an established mathematical relatinship that could be written down. Even if I imitate the original curves as closely as possible, I want a parameterized model for the curve to ulimately produce it." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "5136854e-e9b1-4845-83d4-b8925bd6b4bf", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# archiving these weights and offsets: specific to the 15 and 95 endpoints\n", + "indices = [ 15, 95]\n", + "values = [0.0315, 0.0236]\n", + "\n", + "accent_weights = {\n", + " \"red\": 4.0,\n", + " \"orange\": 3.0,\n", + " \"yellow\": 0.5,\n", + " \"green\": 0.5,\n", + " \"blue\": 0.8,\n", + "}\n", + "accent_offsets = {\n", + " \"red\": -5,\n", + " \"orange\": -3,\n", + " \"yellow\": 0,\n", + " \"green\": 0,\n", + " \"blue\": -1,\n", + "}\n", + "hue_bez_cmax_map = {}\n", + "for i, (hue_key, hue_val) in enumerate(accent_hue_map.items()):\n", + " cmax_idx = np.argmax(hue_cmax_map[hue_key])\n", + " cmax_idx += accent_offsets[hue_key]\n", + "\n", + " cmax_lightness = lightness_levels_n1[cmax_idx]\n", + " cmax_chroma = hue_cmax_map[hue_key][cmax_idx]\n", + "\n", + " P0 = np.array([indices[0], values[0]])\n", + " P1 = np.array([cmax_lightness, cmax_chroma])\n", + " P2 = np.array([indices[-1], values[-1]])\n", + " \n", + " t = np.linspace(0, 1, 400)[:, None]\n", + " B = quad_bezier_rational(P0, P1, P2, w=accent_weights[hue_key], t=t)\n", + " \n", + " hue_bez_cmax_map[hue_key] = B\n", + "\n", + "fig, axes = plt.subplots(len(hue_cmax_map), 1, sharex=True, sharey=True, figsize=(6, 10))\n", + "for ax, hue_key in zip(axes, accent_hue_map):\n", + " ax.grid(True, alpha=0.3)\n", + " ax.text(1.01, 0.5, hue_key, transform=ax.transAxes, va='center')\n", + " \n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_key])\n", + " ax.plot(hue_bez_cmax_map[hue_key][:,:,0], hue_bez_cmax_map[hue_key][:,:,1], c='b', alpha=0.4)\n", + " ax.plot(lightness_levels_n5, mb_chroma_pts[hue_key], c='r', alpha=0.3)\n", + "\n", + " max_idx = np.argmax(mb_chroma_pts[hue_key])\n", + " spline_indices = [0, max_idx-1, max_idx+1, -1]\n", + " \n", + " ax.scatter(\n", + " np.array(lightness_levels_n5)[spline_indices],\n", + " np.array(mb_chroma_pts[hue_key])[spline_indices],\n", + " s=8, c='g'\n", + " )\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Max chroma at different lightness levels w/in sRGB gamut\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "5eb9adc3-cc6e-4471-ab0c-29a8689e8bd7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAPZCAYAAADnTaW6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4VNXWwOHfzCSZSe+FdEJCAiQQCCFUqYINu6BYEMWGeK9iv5+i3KtiQcCCoiLYQIpgV4oIivTeExJIgYR00vvM+f44ZCAkQAIZEsh6n2ceyJkzZ/bsaWv2XnsdjaIoCkIIIYQQ4ry0Ld0AIYQQQojLhQROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETq3coEGDiIyMbOlmXHFSUlLQaDR88cUX5m2vvvoqGo2mzn41NTU899xzBAQEoNVqufnmmwEoKSlh/Pjx+Pj4oNFoePLJJy9d4y0sODiY+++/3/z32rVr0Wg0rF27tsnHqr3td99913wNbOXuv/9+goODW7oZQOtqy+kGDRrEoEGDWroZQlyQKzpw+uKLL9BoNGg0Gv7555961yuKQkBAABqNhhtuuKEFWiguxEcffVQn4LGkuXPn8s4773D77bfz5Zdf8tRTTwHwxhtv8MUXX/DYY4/x9ddfc++9916S9lyIBQsWMHPmzJZuxnldLu0UTWcymfD09OTtt99usTbcf//95u8DjUaDXq+nY8eOTJ48mYqKigZvU1lZyQcffED//v1xdXXFxsYGX19fbrzxRr799luMRqN539ofY6dfnJyciI6O5sMPP6yz75UoIyODV199lV27drV0UyzOqqUbcCkYDAYWLFhA//7962z/66+/OHbsGHq9voVaJi7ERx99hIeHR51Rkebw0ksv8cILL9TZ9ueff+Ln58eMGTPqbe/duzevvPJKs7bBEhYsWMC+ffsueFTsqquuory8HBsbm+Zt2Bkutp2i9dqyZQu5ublcf/31AKxcubJF2qHX65kzZw4AhYWF/Pjjj/zvf//j8OHDzJ8/v86+OTk5XHvttWzfvp0RI0bw0ksv4ebmRmZmJn/88QdjxowhKSmJl19+uc7t7rrrLq677jrzffz222888cQTpKam8s4771yaB9oCMjIymDJlCsHBwURHR7d0cyyqTQRO1113HUuWLOH999/HyurUQ16wYAExMTHk5ua2YOssp6KiAhsbG7TaK3pgsdlYWVnVeX0AZGdn4+LiUm/f7OxsOnfu3Gz3bTKZqKqqwmAwNNsxm4tWq22V7RKXj99++42goCC6dOkCYPEg/GysrKy45557zH9PmDCBvn378u233zJ9+nS8vb3N1917773s3LmTpUuXcuutt9Y5zosvvsi2bdtISEiodx89evSodx9xcXEsWLDgig6c2pI28Y161113kZeXx6pVq8zbqqqq+O677xgzZkyDt5k2bRp9+/bF3d0dW1tbYmJi6uVpzJs3D41Gw9y5c+tsf+ONN9BoNPz222/nbdvvv//OwIEDcXR0xMnJidjYWBYsWFBvvwMHDjB48GDs7Ozw8/OrN+Rdm0uycOFCXnrpJfz8/LCzs6OoqAiAJUuWEBMTg62tLR4eHtxzzz2kp6fXOcb999+Pg4MDaWlp3HDDDTg4OODn58esWbMA2Lt3L0OGDMHe3p6goKB67czPz+eZZ54hKioKBwcHnJycuPbaa9m9e/d5+wHU/hwyZAheXl7o9Xo6d+7Mxx9/XGef4OBg9u/fz19//WUeDj9frkRBQQH3338/zs7OuLi4MHbsWAoKCurtd3qOU+2w+5o1a9i/f7/5vmr7OTk5mV9//dW8PSUlBVCH9l955RVCQ0PR6/UEBATw3HPPUVlZWee+NBoNEydOZP78+XTp0gW9Xs/y5csBSE9P54EHHsDb2xu9Xk+XLl3qvcZq27F48WJef/11/P39MRgMDB06lKSkJPN+gwYN4tdffyU1NdXc1qbmvJwtx2nWrFmEhIRga2tLr169WLdu3VlzV0wm0wW3s7GPtdbmzZu55pprcHZ2xs7OjoEDB7J+/fo6+xQXF/Pkk08SHByMXq/Hy8uLq6++mh07dpj3SUxM5LbbbsPHxweDwYC/vz933nknhYWFTeq/2sc/c+ZMunTpgsFgwNvbm0ceeYQTJ06Y97nhhhsICQlp8PZ9+vShZ8+edbZ988035ve0m5sbd955J0ePHj1vWxYuXEhMTIz5MycqKor33nvvnLfp0aNHveAhKioKjUbDnj17zNsWLVqERqPh4MGDdfb99ddfzaNNUD/HqanP8Zka83w2RKPR0L9/fxRF4ciRI+btGzduZMWKFTz88MP1Hnetnj17cvfdd5+3bRqNBm9v73o/ys5myZIldO7cGYPBQGRkJN9//32DuWqN+Y6qvf+JEyeaj2tra0ufPn3Yu3cvAJ988gmhoaEYDAYGDRpk/iyrdWbOY63Tn8O1a9cSGxsLwLhx48zv4UuVUnHJKVewefPmKYCydetWpW/fvsq9995rvu6HH35QtFqtkp6ergQFBSnXX399ndv6+/srEyZMUD788ENl+vTpSq9evRRA+eWXX+rsd8MNNyjOzs5KWlqaoiiKsmfPHsXGxkZ58MEHG9U+jUajREZGKq+//roya9YsZfz48XXaOXDgQMXX11cJCAhQ/v3vfysfffSRMmTIEAVQfvvtN/N+a9asUQClc+fOSnR0tDJ9+nRl6tSpSmlpqbkfYmNjlRkzZigvvPCCYmtrqwQHBysnTpwwH2Ps2LGKwWBQOnfurDz66KPKrFmzlL59+yqAMm/ePMXX11d59tlnlQ8++EDp0qWLotPplCNHjphvv3XrVqVDhw7KCy+8oHzyySfKf//7X8XPz09xdnZW0tPTz9sfsbGxyv3336/MmDFD+eCDD5Thw4crgPLhhx+a9/n+++8Vf39/JSIiQvn666+Vr7/+Wlm5cuVZj2kymZSrrrpK0Wq1yoQJE5QPPvhAGTJkiNK1a1fz46r1yiuvKLVviZKSEuXrr79WIiIiFH9/f/N9ZWZmKl9//bXi4eGhREdHm7eXlJQoRqNRGT58uGJnZ6c8+eSTyieffKJMnDhRsbKyUm666aY67QKUTp06KZ6ensqUKVOUWbNmKTt37lQyMzMVf39/JSAgQPnvf/+rfPzxx8qNN96oAMqMGTPqPd/du3dXYmJilBkzZiivvvqqYmdnp/Tq1cu838qVK5Xo6GjFw8PD3Nbvv//+nM9DUFCQMnbs2Hr3tWbNGvO2jz76SAGUAQMGKO+//74yadIkxc3NTenQoYMycODAZm1nY4+hKIqyevVqxcbGRunTp4/y7rvvKjNmzFC6du2q2NjYKJs3bzbvN2bMGMXGxkaZNGmSMmfOHOWtt95SRo4cqXzzzTeKoihKZWWl0r59e8XX11d57bXXlDlz5ihTpkxRYmNjlZSUlHP239ixY5WgoKA628aPH69YWVkpDz30kDJ79mzl+eefV+zt7ZXY2FilqqpKURRF+eqrrxRA2bJlS53bpqSkKIDyzjvvmLe99tprikajUUaPHq189NFHypQpUxQPD48G39Ont2XlypUKoAwdOlSZNWuWMmvWLGXixInKHXfccc7H9K9//Uvx9PQ0/52Xl6doNBpFq9XWeX8+/vjjdfZTFEU5fvy4otFo6nx2Dhw48IJeJ2dzvuezti/s7e3r3fb2229XAOXgwYPmbS+++KICKP/8889577tWcnKyAihTpkxRcnJylJycHOXw4cPKhx9+qFhZWSkvv/zyeY/xyy+/KBqNRunatasyffp05eWXX1ZcXV2VyMjIeq+pxn5HAUrXrl2VgIAA5c0331TefPNNxdnZWQkMDFQ+/PBDpXPnzsq7776rvPTSS4qNjY0yePDgOrc/8/Og1unPYWZmpvLf//5XAZSHH37Y/B4+fPhwo/vvctJmAqcPP/xQcXR0VMrKyhRFUZQ77rjD/AJpKHCq3a9WVVWVEhkZqQwZMqTO9uPHjytubm7K1VdfrVRWVirdu3dXAgMDlcLCwnO2raCgQHF0dFTi4uKU8vLyOteZTCbz/wcOHKgAyldffWXeVllZqfj4+Ci33XabeVvtB09ISEidtldVVSleXl5KZGRknfv55ZdfFECZPHmyedvYsWMVQHnjjTfM206cOKHY2toqGo1GWbhwoXl7fHy8AiivvPKKeVtFRYViNBrrPJbk5GRFr9cr//3vf8/ZH4pSv88VRVFGjBihhISE1NnWpUuXOh+65/LDDz8ogPL222+bt9XU1CgDBgw4Z+BUa+DAgUqXLl3qHbeh18zXX3+taLVaZd26dXW2z549WwGU9evXm7cBilarVfbv319n3wcffFBp166dkpubW2f7nXfeqTg7O5v7qPb57tSpk1JZWWne77333lMAZe/eveZt119/fb0P3XM5X+BUWVmpuLu7K7GxsUp1dbV5vy+++EIBGvxCvJh2NvYYJpNJCQsLU0aMGFHnPVRWVqa0b99eufrqq83bnJ2dlccff/ysfbBz504FUJYsWXL2jjqLM4OVdevWKYAyf/78OvstX768zvbCwkJFr9crTz/9dJ393n77bUWj0SipqamKoqiBlE6nU15//fU6++3du1exsrKqs/3Mtvz73/9WnJyclJqamiY9piVLliiAcuDAAUVRFOWnn35S9Hq9cuONNyqjR48279e1a1fllltuqXPbzz//XLG1ta3z/j5b4NSY10lDzvd8KsqpwKk2qElKSlKmTZtm/vF6+mvmlltuUQCloKCgzjHKy8vNt8/JyakTpNYGTg1dHnvssTrHP5uoqCjF399fKS4uNm9bu3atAtR7bzT2OwpQ9Hq9kpycbN72ySefKIDi4+OjFBUVmbfXBoyn79uYwElR1B/OZ36mXqnaxFQdwKhRoygvL+eXX36huLiYX3755azTdAC2trbm/584cYLCwkIGDBhQb+jXx8eHWbNmsWrVKgYMGMCuXbuYO3cuTk5O52zPqlWrKC4u5oUXXqiXP3LmkngHB4c6c+Y2Njb06tWrztByrbFjx9Zp+7Zt28jOzmbChAl17uf6668nIiKCX3/9td4xxo8fb/6/i4sL4eHh2NvbM2rUKPP28PBwXFxc6rRBr9eb86mMRiN5eXk4ODgQHh5+3iFzqNvnhYWF5ObmMnDgQI4cOXJB0yOg5lZYWVnx2GOPmbfpdDqeeOKJCzreuSxZsoROnToRERFBbm6u+TJkyBAA1qxZU2f/gQMH1smTUhSFpUuXMnLkSBRFqXOMESNGUFhYWK8fx40bVydfZMCAAQANvjaay7Zt28jLy+Ohhx6qM/1w99134+rq2uBtmqOd5zvGrl27SExMZMyYMeTl5Zn7rrS0lKFDh/L3339jMpkA9XW9efNmMjIyGrwvZ2dnAFasWEFZWVmj29iQJUuW4OzszNVXX13nOY2JicHBwcH8uqid2l68eDGKophvv2jRInr37k1gYCAAy5Ytw2QyMWrUqDrH8/HxISwsrN7r7HQuLi6UlpbWSVtojNq+/vvvvwFYt24dsbGxXH311axbtw5Qp8T37dtn3rfWb7/9xuDBg+u8v8/mQl8n53s+a5WWluLp6YmnpyehoaE888wz9OvXjx9//LHO525tioODg0Od28+ePdt8e09Pz3oLjgAefvhhVq1axapVq1i6dCmPP/44n3zyCZMmTTpn2zIyMti7dy/33XdfnfsdOHAgUVFR9fZv7HcUwNChQ+tM9cXFxQFw22234ejoWG+7JT8/rgRtIjkcwNPTk2HDhrFgwQLKysowGo3cfvvtZ93/l19+4bXXXmPXrl118lPODGoA7rzzTr755ht+/fVXHn74YYYOHXre9hw+fBigUTWa/P39692vq6trndyCWu3bt6/zd2pqKqAGOmeKiIioV6bBYDDg6elZZ5uzs3ODbXB2dq6To2EymXjvvff46KOPSE5OrrP81t3d/VwPEYD169fzyiuvsHHjxnpfVoWFheYvs6ZITU2lXbt29T4AG+qPi5WYmMjBgwfr9V+t7OzsOn+f+Vzl5ORQUFDAp59+yqefftqoY9R+mdaqDVxOf16aW+1rKjQ0tM52Kyurs+ZPNUc7z3eMxMREQP3xcDaFhYW4urry9ttvM3bsWAICAoiJieG6667jvvvuM+cYtW/fnkmTJjF9+nTmz5/PgAEDuPHGG7nnnnua/DpMTEyksLAQLy+vBq8//TkdPXo0P/zwAxs3bqRv374cPnyY7du31ynTkJiYiKIohIWFNXg8a2vrs7ZlwoQJLF68mGuvvRY/Pz+GDx/OqFGjuOaaa875GLy9vQkLC2PdunU88sgjrFu3jsGDB3PVVVfxxBNPcOTIEQ4ePIjJZKoTOFVXV7Nq1SqmTp16zuPXutDXyfmez1oGg4Gff/4ZgGPHjvH222+TnZ1dL6irDSZKSkrqPN+33Xab+TP76aefbrDEQFhYGMOGDTP/feutt6LRaJg5cyYPPPBAg0EQnP19VbvtzICoKd9RZ/Zr7WMKCAhocLslPz+uBG0mcAIYM2YMDz30EJmZmVx77bUNrpYC9dfUjTfeyFVXXcVHH31Eu3btsLa2Zt68eQ0mbufl5bFt2zZATeI2mUzNupJNp9M1uP30X6W1GvOr7kLuqzFteOONN3j55Zd54IEH+N///oebmxtarZYnn3zS/Ev/bA4fPszQoUOJiIhg+vTpBAQEYGNjw2+//caMGTPOe/vWwGQyERUVxfTp0xu8/swPqTOfq9rHeM8995z1y79r1651/m7Ka6MlNUc7z3eM2v575513zrocujaAHjVqFAMGDOD7779n5cqVvPPOO7z11lssW7aMa6+9FoB3332X+++/nx9//JGVK1fyr3/9i6lTp7Jp0yb8/f0b3W6TyYSXl1e95e61Tg+0R44ciZ2dHYsXL6Zv374sXrwYrVbLHXfcUed4Go2G33//vcE+OfNHwum8vLzYtWsXK1as4Pfff+f3339n3rx53HfffXz55ZfnfBz9+/dn9erVlJeXs337diZPnkxkZCQuLi6sW7eOgwcP4uDgQPfu3c23+eeffygqKjIvzz+fC32dNOb5rD3+6UHNiBEjiIiI4JFHHuGnn34yb4+IiABg37599OvXz7w9ICDA/D52dXVt9IrsoUOH8uGHH/L333+fNXBqiqZ+R13M53pDgRioswpnu/2Vrk0FTrfccguPPPIImzZtYtGiRWfdb+nSpRgMBlasWFGnxtO8efMa3P/xxx+nuLiYqVOn8uKLLzJz5szzDst26NABUN+YDf3CaC5BQUEAJCQkmKeMaiUkJJivbw7fffcdgwcP5vPPP6+zvaCgAA8Pj3Pe9ueff6ayspKffvqpzq+jhqYdzvZGbkhQUBCrV6+mpKSkzhdKQ8uIL1aHDh3YvXs3Q4cObVIba3l6euLo6IjRaKzz4X6xLqQt51L7mklKSmLw4MHm7TU1NaSkpNQL7hrrYttZ+55ycnJqVP+1a9eOCRMmMGHCBLKzs+nRowevv/56nS/aqKgooqKieOmll9iwYQP9+vVj9uzZvPbaa01q1x9//EG/fv3O+8PG3t6eG264gSVLljB9+nQWLVrEgAED8PX1rXM8RVFo3749HTt2bHQ7atnY2DBy5EhGjhyJyWRiwoQJfPLJJ7z88svn/CwaMGAA8+bNY+HChRiNRvr27YtWq6V///7mwKlv3751vkx//fVXOnfufEmqlzfm+WzoNk899RRTpkxh06ZN9O7dG1BXOL755pvMnz+/TuB0oWpqagB1BOtsTn9fnenMbU39jroYrq6uDa5CTk1NrTOi19yfM61Zm8lxAvWX2Mcff8yrr77KyJEjz7qfTqdDo9HUqwr7ww8/1Nv3u+++Y9GiRbz55pu88MIL3Hnnnbz00kscOnTonG0ZPnw4jo6OTJ06tV7V2uYcLejZsydeXl7Mnj27znDu77//zsGDB+ssEb5YOp2uXtuXLFlSr+zB2W4LdR97YWFhgx8E9vb2Db6RG3LddddRU1NTp6yB0Wjkgw8+aNTtm2LUqFGkp6fz2Wef1buuvLyc0tLSc95ep9Nx2223sXTpUvbt21fv+pycnAtql729/QXniDWkZ8+euLu789lnn5m/EADmz59/UUP8F9vOmJgYOnTowLRp0xr8gqrtP6PRWO9+vLy88PX1Nb9HioqK6jw2UIMorVZbr7TE+YwaNQqj0cj//ve/etfV1NTUey2PHj2ajIwM5syZw+7duxk9enSd62+99VZ0Oh1Tpkyp935TFIW8vLyztuXM67RarTnQPd/jqp2Ce+utt+jatat5WmfAgAGsXr2abdu2NZjf1JyfMQ1pzPN5Lk888QR2dna8+eab5m39+vXj6quv5tNPP+XHH39s8HZN+ZyunR7s1q3bWffx9fUlMjKSr776qs7r96+//jKXDqjVlO+oi9WhQwc2bdpEVVWVedsvv/xSr/SFvb09QKM/my9nbWrECc6d/1Dr+uuvZ/r06VxzzTWMGTOG7OxsZs2aRWhoaJ28ouzsbB577DEGDx7MxIkTAfjwww9Zs2YN999/P//8889Zp+ycnJyYMWMG48ePJzY2ljFjxuDq6sru3bspKys777B5Y1lbW/PWW28xbtw4Bg4cyF133UVWVhbvvfcewcHB5lOINIcbbriB//73v4wbN46+ffuyd+9e5s+ff9baNKcbPny4+ZfwI488QklJCZ999hleXl4cP368zr4xMTF8/PHHvPbaa4SGhuLl5VVvNK3WyJEj6devHy+88AIpKSl07tyZZcuWNWsgUevee+9l8eLFPProo6xZs4Z+/fphNBqJj49n8eLFrFixol4tnjO9+eabrFmzhri4OB566CE6d+5Mfn4+O3bs4I8//iA/P7/J7YqJiWHRokVMmjSJ2NhYHBwczvnD4XxsbGx49dVXeeKJJxgyZAijRo0iJSWFL774gg4dOlzwL8+LbadWq2XOnDlce+21dOnShXHjxuHn50d6ejpr1qzBycmJn3/+meLiYvz9/bn99tvp1q0bDg4O/PHHH2zdupV3330XUCvDT5w4kTvuuIOOHTtSU1PD119/bQ5um2LgwIE88sgjTJ06lV27djF8+HCsra1JTExkyZIlvPfee3XyLa+77jocHR155plnGry/Dh068Nprr/Hiiy+SkpLCzTffjKOjI8nJyXz//fc8/PDDPPPMMw22Zfz48eTn5zNkyBD8/f1JTU3lgw8+IDo6mk6dOp3zcYSGhuLj40NCQkKdxRVXXXUVzz//PECdwCk5OZmDBw/Wq8XW3BrzfJ6Lu7s748aN46OPPuLgwYPmfvjmm2+45ppruPnmm7n22msZNmwYrq6u5srhf//9d4OjWTt27OCbb74xt2316tUsXbqUvn37Mnz48HO25Y033uCmm26iX79+jBs3jhMnTvDhhx8SGRlZJ5hq7HdUcxg/fjzfffcd11xzDaNGjeLw4cN888035hHeWh06dMDFxYXZs2fj6OiIvb09cXFx9XI5rwiXehnfpXR6OYJzaWhp+eeff66EhYUper1eiYiIUObNm1dvufqtt96qODo61qvr8uOPPyqA8tZbb523jT/99JPSt29fxdbWVnFyclJ69eqlfPvtt+brz7Yc/sxlxrXLec+2fHrRokVK9+7dFb1er7i5uSl33323cuzYsXrHbKjOSWOX5FdUVChPP/200q5dO8XW1lbp16+fsnHjxnrLVs/mp59+Urp27aoYDAYlODhYeeutt5S5c+fWWx6bmZmpXH/99Yqjo2O95e8NycvLU+69917FyclJcXZ2Vu69917zcvPmLEegKOqS4Lfeekvp0qWLotfrFVdXVyUmJkaZMmVKnRIVwFmXT2dlZSmPP/64EhAQoFhbWys+Pj7K0KFDlU8//dS8z9me79ol0ac/rpKSEmXMmDGKi4tLg8uaG3ps56vjpCiK8v777ytBQUGKXq9XevXqpaxfv16JiYlRrrnmmmZtZ1OOoShqKYFbb71VcXd3V/R6vRIUFKSMGjVKWb16taIoajmFZ599VunWrZvi6Oio2NvbK926dVM++ugj8zGOHDmiPPDAA0qHDh0Ug8GguLm5KYMHD1b++OOPc/adojRcx0lRFOXTTz9VYmJiFFtbW8XR0VGJiopSnnvuOSUjI6PevnfffbcCKMOGDTvr/SxdulTp37+/Ym9vr9jb2ysRERHK448/riQkJJy1Ld99950yfPhwxcvLS7GxsVECAwOVRx55RDl+/Ph5H5eiqGVcAGXRokXmbVVVVYqdnZ1iY2NTp+TJhx9+qDg7O9cpWVHrbOUIGvscn64xz2dtXzT0+aYoinL48GFFp9PVW3ZfXl6uzJw5U+nTp4/i5OSkWFlZKT4+PsoNN9ygzJ8/v05Zh4bKEVhZWSkhISHKs88+W6fEwLksXLhQiYiIUPR6vRIZGan89NNPym233aZERETU2a8x31GK0vBnTW1bT68Npihnfx7effddxc/PT9Hr9Uq/fv2Ubdu2Nfi5/uOPPyqdO3dWrKysrujSBBpFaWVZpEKIy1LtiVxvvfXWBqcrRdty3XXX4eDgwOLFi1u6KZe96OhoPD09m1xGQlhGm8pxEkI0j4qKino5Hl999RX5+fnnPQWOaBsGDRrUrKkAbUF1dXW93Lq1a9eye/dueV+1IjLiJIRosrVr1/LUU09xxx134O7uzo4dO/j888/p1KkT27dvb7GTuApxOUtJSWHYsGHcc889+Pr6Eh8fz+zZs3F2dmbfvn2NqocnLK/NJYcLIS5ecHAwAQEBvP/+++Tn5+Pm5sZ9993Hm2++KUGTEBfI1dWVmJgY5syZQ05ODvb29lx//fW8+eabEjS1IjLiJIQQQgjRSJLjJIQQQgjRSBI4CSGEEEI0kgROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETkIIIYQQjSSBkxBCCCFEI0ngJIQQQgjRSBI4CSGEEEI0kgROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETkIIIYQQjSSBkxBCCCFEI0ngJIQQQgjRSBI4CSGEEEI0kgROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSVUs3oDFMJhMZGRk4Ojqi0WhaujlCCCFEm6QoCsXFxfj6+qLVts2xl8sicMrIyCAgIKClmyGEEEII4OjRo/j7+7d0M1rEZRE4OTo6AuoT5eTk1GzHNZlM5OTk4Onp2WYjZ0uS/rUs6V/Lkv61LOlfy7JU/xYVFREQEGD+Xm6LLovAqXZ6zsnJqdkDp4qKCpycnOSNawHSv5Yl/WtZ0r+WJf1rWZbu37acNiOvViGEEEKIRpLASQghhBCikSRwEkIIIYRopMsix0kIIVqjaqOJ5NxS4jOLScgsIv54MeXVRt68tSuB7nYt3TwhhAVI4CSEEE1UUW3km02pfLT2MPmlVfWuf/jrbSyb0Bc7G/mIFeJKI+9qIYRopBqjie+2H+O91YkcL6wAwN5GR7iPI+E+ToR5OfDR2sPEZxbz3Hd7+OCu7m169ZEQVyIJnIQQ4jxMJoXf9h1n+spDHMktBaCds4Enh4VxWw9/rHSn0kWj/J2569NN/LLnON38XXjoqpCWarYQwgIkcBJCiLNQFIW1CTm8u+oQ+zOKAHCzt+HxwaHcHReIwVpX7zaxwW5MHtmZyT/uZ+rvB+ns60S/UI9L3XQhhIVI4CSEEA3YmpLPG78cYndGCQAOeiseGhDCgwPa46A/90fnvb2D2H20kKU7jjFxwQ5+fqI//q6SLC7ElUACJyGEOM2+9EKmrUxgbUIOAHorLWP7BvPowA642ds06hgajYbXb4kkIauIfelFPPL1dr57tC+2NvVHqIQQlxcJnIQQAjiSU8L0VYf4Zc9xAHRaDSM7u/Pc9VH4XsBokcFaxyf39uTGD/5hf0YRzy3dw/t3RkuyuBCXOQmchBBtWkZBOe+vTmTJ9mMYTQoaDdzYzZd/Dw3FzliKl7Phgo/t52LLR3f34O45m/l5dwad2znx2KAOzdh6IcSlJoGTEKJNyiup5KO1h/l6UypVNSYAhkZ48cyIcDq1c8JkMpGdXXrR9xMX4s6rN3bhpR/28faKeCJ8HBkc4XXRxxVCtAwJnIQQbUpxRTWfrUvm83VHKK0yAhDX3o3nrgknJsjNIvd5T+8gDhwvYsHmNP717U5+mNiPDp4OFrkvIYRlSeAkhGgTKqqNfLUxhY/WHqagrBqAKD9nnh0RzoAwD4vnHr06sguJWcVsTTnBQ19u4/vH++Fsa23R+xRCND8JnIQQV7Rqo4nF247y/upEsooqAejgac/Tw8O5NtLnkiVr21hp+fieGG784B+O5JYyccEO5t0fW6d4phCi9ZPASQhxRTKZFH7ek8H0VYdIzSsD1GTtfw8L49bufi0SsHg46PlsbE9u/3gj6xJzee3Xg7x6Y5dL3g4hxIWTwEkIcUVRFIU/47N5Z0UC8ZnFAHg4qNW+x8QFordq2VpKXXydmTG6G49+s4MvNqTQ0duRMXGBLdomIUTjSeAkhLhibDqSxzsrEtieegIAR70VjwwMYVy/9tifp9r3pXRNZDuevroj7646xOQf99Hew54+HdxbullCiEZoPZ8kQghxgfYeK+TtFfGsS8wFwGCtVvt+bGAHXOwaV+37Ups4JJTE7BJ+2p3BY/O38+Pj/Qhyt2/pZgkhzkMCJyHEZSspu4TpqxL4bW8mAFZaDXf2CuCJIWF4O1144cpLQaPR8PbtXUnNK2X3sUIe+GIryybISjshWjsJnIQQl51jJ8p4749Elu44hkkBjQZujvbjqWEdCXS/fE6ma7DW8dl9Pblp1noO55QyYf52vhjXC2tZaSdEqyWBkxDispFbUsmHfyaxYHMaVUa12vfVnb15enhHInycWrh1F8bLycDnY2O5Y/YG1iflMfnHfbxxS5Sc006IVkoCJyFEq1dYXs1nfx9h7vpkyk5W++7bwZ1nR4TTPdC1hVt38Tr7OvH+Xd156KttfLvlKCEeDjx0VUhLN0sI0QAJnIQQrVZ5lZEvN6bw8drDFJar1b67+Tvz7IgI+od5tHDrmtfQTt68dH1n/vvLAd74/SCB7naM6OLT0s0SQpxBAichRKtTVWNi0bajfLA6kexitdp3mJcDTw8PZ0QX7yt2Gmtcv2CO5JbwzaY0nly4i0WP9Karv0tLN0sIcRoJnIQQrYbRpPDT7nRmrEokLV+t9u3vastTwzpyc3c/dNorM2CqpdFoeHVkF47ml/PXoRwe+GIb30/oS4Db5ZPwLsSVTgInIUSLUxSFVQeyeHflIRKyaqt96/nX0FDujA3ExqrtrDKz0mmZdXcP7pi9kYPHixj3xVaWPtZXyhQI0UpI4CSEaFEbknJ5e0UCu44WAOBksOLRQR24v28wdjZt8yPKQW/F3Pt7csusDSRll/Do19v58oFebSqAFKK1apufSkKIFrf7aAHvrEjgnyS12rettY4H+gfz8IAOONvJ6Eo7Z1vm3q+WKdh4JI8Xlu7h3VHdrtj8LiEuFxI4CSEuqcSsYqatTGDF/iwArHUa7o4LYsLgDng5tu5q35daZ18nZt3dgwe/3Maynen4udry9PDwlm6WEG3aBY37zpo1i+DgYAwGA3FxcWzZsuWs+3722WcMGDAAV1dXXF1dGTZs2Dn3F0JcmY7mlzFp8S5GzPybFfuz0Grgth7+/Pn0IF69sYsETWcxKNyL126OBOCDP5OYvzm1hVskRNvW5MBp0aJFTJo0iVdeeYUdO3bQrVs3RowYQXZ2doP7r127lrvuuos1a9awceNGAgICGD58OOnp6RfdeCFE65ddXMErP+5jyLtrWbYjHZMC13TxYcWTV/HuqG6yYqwR7uoVyL+GhgHw8g/7+ONAVgu3SIi2S6MoitKUG8TFxREbG8uHH34IgMlkIiAggCeeeIIXXnjhvLc3Go24urry4Ycfct999zXqPouKinB2dqawsBAnp+Y7rYLJZCI7OxsvLy+0Wkm6bG7Sv5bV2vu3sKyaT/4+zLz1KZRXq9W++4d68OyIcLoFuLRs4xqhtfWvoig8v3QPi7cdw2Ct5duHel/WVdNbW/9eaSzVv5b6Pr6cNCnHqaqqiu3bt/Piiy+at2m1WoYNG8bGjRsbdYyysjKqq6txc3NrWkuFEJeFsqoa5q1P4ZO/DlNUUQNAdIALz10TTt8OV1a170tJo9Hw+i1RZBdXsjYhhwe/3MbSx/rS3sO+pZsmRJvSpMApNzcXo9GIt7d3ne3e3t7Ex8c36hjPP/88vr6+DBs27Kz7VFZWUllZaf67qKgIUCNok8nUlCafk8lkQlGUZj2mOEX617JaW/9W1ZhYuPUoH65JIrekCoCO3g48M7wjQyO80Gg0raatjdHa+hdAp4EP7ozmrjmb2ZdexH2fb+a7R/vg6ahv6aY1WWvs3yuJpfpXnq9LvKruzTffZOHChaxduxaD4eyJoFOnTmXKlCn1tufk5FBRUdFs7TGZTBQWFqIoigwVW4D0r2W1lv41mhSWx+czZ1MGx4vUgMnP2YaH+vhydUc3dFoNOTk5Lda+C9Va+rchb10XzCOLEzh6opx7PtvIx3eE46DXtXSzmqQ19++VwFL9W1xc3GzHulw1KXDy8PBAp9ORlVU3MTErKwsfn3OfjHLatGm8+eab/PHHH3Tt2vWc+7744otMmjTJ/HdRUREBAQF4eno2e46TRqPB09NT3rgWIP1rWS3dv4qisGJ/FtNXHSIppxQAL0c9Ewd3YFTPgMu+WGNZVRlZpVkEuAVgZ9O6Eti9gK/Hu3DHJ5tIzC3npeVpzLu/J3rryyd4aunX75XOUv17rkGPtqJJgZONjQ0xMTGsXr2am2++GVCfnNWrVzNx4sSz3u7tt9/m9ddfZ8WKFfTs2fO896PX69Hr6w89a7XaZn+DaTQaixxXqKR/Laul+vefxFzeWRHP7mOFADjbWvPoQLXat63NJfzyrqyE3FxoxpFogA1pG3j8t8fxs23PNutU5t+9lKEhQ5v1Pi5We09HvhjXizs/3cSm5HyeWryHWXf3uKzO5yefD5Zlif6V5+oCpuomTZrE2LFj6dmzJ7169WLmzJmUlpYybtw4AO677z78/PyYOnUqAG+99RaTJ09mwYIFBAcHk5mZCYCDgwMODg7N+FCEEJa2I+0E01YksOFwHgB2Njoe7N+e8QNCLs251KqqIC9PDZZyc6GkpPnvwljFe98/QlB1JSF25ViVFfPumzfS/4n16Nv5g5sbtJIvj0g/Zz69L4b7525l+f5MXv5xH6/fHCnVxYWwoCYHTqNHjyYnJ4fJkyeTmZlJdHQ0y5cvNyeMp6Wl1YlIP/74Y6qqqrj99tvrHOeVV17h1VdfvbjWCyEuiYRMtdr3qpP1g2x0WsbEBfL44FDLJibX1NQNlE4uFKnD2RkcHZvtLrOLjnHIthytrQYvax1KmYKupIwT+7bik3IUrKzAwwO8vMDTE+xadhqvbwcPZt4ZzeMLdrBgcxru9jZSXVwIC7qg5PCJEyeedWpu7dq1df5OSUm5kLsQQrQCaXllzPjjED/sSkdRQKuB22P8+dfQMPxdLRAwGI2Qn68GSXl5UFAAZ5aac3RUAxcPD3B3B+vmHenyqOnEkY1OlFaWonNyZK+LhqAae1xDo+BEkTo9mJmpXgAcHNQgystLHY3SXfo8o+ui2vG/myJ56Yd9fPBnEs621owfEHLJ2yFEWyDnqhNC1JNVVMEHfyaycMtRakxq4HJdlA+Trg4n1OvCptgrairIKM7A19EXg9XJBFOTCU6cODWiVFCgbjudvb0aINUGSw3kPzYng5WBZaOWcftidZTcYO/ErFHfoQ/prQZxRUWQna1eTpxQpwtLSuDIEXUKr3Y0ystLbfslck/vIArKqpi28hCv/XoQFzsbbo/xv2T3L0RbIYGTEMKsoKyKj/86zJcbUqioVgOYqzp68uzwcKL8nS/4uKuPrObWxbdSVFFEoOLIt1d9QF/7cHV0yWisu7Ot7anRJA8PTHpbyspOxidHoaxMzQWvrFQvFRVq6pPJpB7KaFT/bzKpcYxOp/6r1aqzbHo9GAzqv3q9eneOjurAkYMD2NjA0JChpE9K51DaIToGdjy1qk6jUacGnZ0hLAyqq9WArzaQqqg49X9Qp/Fqp/Q8PNQGWNDjg0MpKKtmzj/JPL90D44GK0Z0OfeKZyFE00jgJISgtLKGuf8k8+nfRyiuVKt9xwS58uyIcHqHuF/UsStqKhg/72bCskvwLAVrUzHvpTxGz1u+xkZnA3o9irsHZXYenNC6c6LKnoICKDiqDu6UldWfrbMkGxtwcgIXFwOK4k+2lQEPDzWoqsfaGtq1Uy8AxcWnAqf8fLXxKSnqRatVp/K8vMDb+ywHvDgajYb/u74TheXVLNl+jCcW7OSLcbH0DZWK7UI0FwmchGjDKmuMzN+Uxqw1SeSVqsUrI3wceXZEOENOVvu+YNXVcPQo+Xs3EHn41Oq3Ki1koGMrPugMXckudyR3t5oHfjZa7akRITs7dcTo9FEjGxt1ZKn2otWqg0O1I0+1l+rqUyNVtaNV5tGsklOjV7WDSMXF1iQmqsfT60/FPLUzcTY2ZzTU0VG9dOhwKrG9NpAqKzs1JXnggHqA0FB1ZK0ZaTQapt4aRWF5NSsPZDH+q218Mz6OHpfxee2EaE0kcBKiDaoxmli2I533VieSXlAOQLC7HU9d3ZGRXX3RXkwtoIICdYQlPR1MJlyqbbGuDiDR5MxR/CmsbofBypFdx3thrTuV2K3VqjNgLi7g6qr+6+SkBku2tmogZGk1NeqgUUGBGvMkJxvNaU2VlXD0qHqp5eYG/v7g56cOOtWZibOyUqOs2lNUlZaeCqJyck7938VFDaB8fJrtQVrptLx/V3ce+mob6xJzuX/uFr59uDddfC98ulUIoZLASYg2xGRSWL4/k3dXJnD4ZLVvHycD/xoaxh09/bHWXWB9IqNRDZRSUqjOLSQvT52pyql0It06mPZRv/L7rjlUVJdjsLbl8bhHCPCzNqf+eHioQVNLl0eyslKDNldXCAoCf/8qvLzU6/LyICvrVLxTVKQ+xvx82LNHbbu3txpIBQerx6jD3h7at1cvpaVqMnlamhqlbdumXt+hg3qAZliZZ7DW8cm9Mdz7+Ra2p57gvs+3sOiRPhec3C+EUGkU5VJmD1yYoqIinJ2dKSwsbPZTrmRnZ+Pl5SXVUC1A+teymtK/iqLwd2Iu01YksDddrfbtamfNhEGh3NsnCMOFnqqjuBhTcioF+46Rl1mtVhAo0lLq7EuxezBV9mr04OQEbp5VaB2ziAzxxNvdcElGkC7G+fq3vBwyMtR48dix+rU4nZ3VAKp9ezU3vMHHW1mpjs4lJ6vziKDOCbZvr964GUotFJZXM+azTezPKMLHycCSR/sQ4Nbyp5CRzwfLslT/Wur7+HIiI05CXOG2p+bz1vIEtiTnA2Bvo2P8gBDGD2iPo+ECvphNJsqTM8nekkJ+Yh55eeoUV43enmL3IEr9AnD2tCHMV52+8vGprRFpAwQ050NrUba26gBRhw7q30VFagCVlqb+W1gIu3erFzs7CAlRF+J5ep52EL0ewsPVg6SlqaNQ5eUQHw+JieqwV0iIemcXyNnWmq8e6MXoTzeRlF3CmDmbWPJIX3yc5ZxjQlwICZyEuEIdyCji3ZUJrI5Xl8bbWGm5r3cQjw3qgLtD02shFRwv5/imVE7sTqMop1LdqNFQ7uRNlW8wHhEehAVo8Pe/pOWLWg0nJ+jcWb1UVanBU3KyGg+VlcG+feqltpJBaKh6G0CdIwwJUUeZjh+HpCQ1EjtyRD2In58aXF3gL3x3Bz3zx8dxx+yNpOWXMeazTSx8pDdejhI8CdFUEjgJcYVJzi1lxqpD/LQ7AwCdVsOonv48MSQMX5emjVxkZSoc3ZHDiZ0pGI9nm+sCGK0N2IQG4hETRECYAXf3S5O8fbmwsVHjoJCQU+lfiYnqrFxhoZrStG2bOiLXqZM6M6fToSZK+fmpl5wcNYDKzVWjsGPHLmolnreTgQUPxTH6k00cyS3lnjmbWfhwH9zsz1waKIQ4FwmchLhCZBZW8N7qRBZvO4rxZLXvG7q2Y9LVHQnxbHxCcE4OHDlYSda2o2iPpmJVVQao3+mOIR64xwTj18Mbe0fJS2kMnQ4CA9VLdbU6gJSUpAZTx4+rF70eOnZUgygXl5M39PRULwUFcPiwuuNFrsTzd7Vj/vg4Rn+6kUNZJdwzZzPfPtQbZ7tLcIJmIa4QEjgJcZk7UVbFJ38n8+WGFCpr1Grfg8M9eXp4OJF+jVt+np+vfjen7C9Fm3QIu8IMbEwm9Xy2Ada4Rwfg3SsIGzdZkXUxrK3VAKljRzWZPCFBvZSUwN696qVdO4iKUtObNBrUICkmptlW4gV72DN/fG/u/HQjB44Xcd/czXw9Pg6nC8l3E6INklV1sqrDYqR/LauovIoPVuzj253ZlFSqpy2JDXbl2RER9Grvdt7bFxer00dJSVCcXYZzViIOJ46i0yp4eoJ3uAuescFYBfq2yIlrW9qlev0qilobKj4eUlNPVUl3dIQuXSAi4oxCm820Ei8+s4g7P91EQVk1PQJd+OrBOBz0l+63tHw+WJasqrMcCZzkjWsx0r+WUVFtZP7mND46rdp3p3ZOPDcinEHhnues9l1VpX7fHjqkzvzoqitwzjqEU+FRPN1N+PiAZxcvrLqEnzZn1Da1xOu3tBT274eDB9X4CNQ4KDwcIiPPyA2vqam7Eg/UJPOICDWAasQU3r70QsZ8tomiihp6BrnyxQO9LlnwJJ8PliWBk+VI4CRvXIuR/m1eNUYTS3cc470/EskorAAgwEXPs9d04oZzVPtWFDWf5tAhdaCipga01ZU45yQRTAq+Pia8vMDa11P9hq5XubFtasnXb02NOhK4dy+cOKFu02jUWbnoaLVi+WkNrbsSD9Sle127Nir43XuskLvnqMFTr2A35o2Lxf4SBE/y+WBZEjhZjuQ4CdHKmUwKv+/L5N1VCRw5We27nbOBfw0JZYC/Db7tvBsMmgoK1GApMVEdyQDQ1lQRUHGYjtbJ+HUxYjCgfgtHRDT7OdPEhasdOIqIUBfT7dmj/puUpF4CA6F795Nnc6ldiefrq871xcerS/fWrVNHniIizjl9F+XvzNcPxnHP55vZkpLPA19sZd64WOxs5OtBiIbIO0OIVkpRFP46lMM7KxLYn6GOJLjZ2zBhUAfu6R2EjU5DdnZ2ndvU1KhTcQcPQmbmqe0GXTVdDIfpoE3GxeHk2XRdXdURpjoVGUVr4++vXnJzYdeuU/nhaWlqInn37ur1aDRqoNSunTrfd/IUOBw/riZL+fmd9T66Bbjw1QO9uO/zLWxOVoOnufdL8CREQ+RdIUQrtC0ln7eXJ7AlRa327aC3YvyA9jzY/1S1b5PJZN7/xAk1WEpMPJUbo9FAoG8NnQzJ+FUcRmc6mUjs7KwGTLUnnxWXBQ8PGDbsVEXy2jy148fVqgQ9e6qDTuj10KOHOiy1Z4863Lhjh5qBHhV11uqk3QNd+fJBNXjadCSf++dtZd79l2baTojLieQ4yRy7xUj/Nt3+jEKmrUhgTUIOoFb7HtsniMcGhdYrVFhVZWLr1jxyctzJzj7Vvw4OEBFmJMKQgl1GkpoRDuoyrfDwJtf+aata++u3tFQNoA4eVItsgho4xcSog06Amv+UlKRG1CaTOq0XGqqWLj/LY9qRdoKxn2+huLKG2GBX5o2zTMJ4a+/fy53kOFmO/JQQohVIzi1l+qpD/HxGte9/DQ2jnXPdat/5+WoaS3w85OXZ4OioVgsICoJO4Sb8a1LQHE46NfRkb68GTL6+EjBdQeztoW9f6NZNncI7eFA96XBGhjor17MneHtr1aJRfn5qpnlOjjpUlZ6ujj41ME3bI9CVr8fHce/nm9macoKxc7fwxbjYCzuvoRBXIAmchGhBxwvLeX91Iou3HTNX+76xmy9PXd2R9h6nplRMJjVdZf9+dWqmdpuDg0JsrBow2eUdVb8UK9QVd9jZqV+a/v4SMF3B7O2hX79TAVR8vBoXpaerwXSvXuDqag+9e6tR1f796nDVpk1qQNW5M+oqgVOiA1yYPz6Oe+ZsZnvqCe6bu4UvH+glRTKFQAInIVpEXkklH689zFebUqk6We17SIQXzwwPp7PvqeHv8nJ1JOHgwVMr42pzgMPDwdqqHO/qQrSbk9QzyYL6JdixIwQEnHU6Rlx5HBygf381gNq5U61InpqqJpF37KhO4Tn4+qrnu4uPVyPx9HTIymqw9lNXfxcWPNSbu+dsZmdaAffM2cxXD/TCxU7ObSfaNgmchLiEiiuqmbMumTnrjlBapSam9GrvxnMjwukZfKo4T3Y27NunrqCqzQG3tVXPZdapE9jbKZiOpVOwYbO61FyrVZOCw8LUYQYJmNosR0e46iq1jNPWreoqy4QENdUpMhKio63QR0aqgfWePWrdin371OTxM2o/Rfo5s+ChOO79fAt7jhVy12eb+ebBXrg76Fvs8QnR0iRwEuISqKg28vXGVD5am8SJMnV1W6SfE8+OiOCqMA80Gg1Go3q+uP371VSUWl5e6hde+/ag05jUUYLNiVBcjKasTM1T6dhRHTFog6dGEQ1zcYGrr1aD8M2b1Sne2mTy7t2hSxdnrPr3r1/7qX37k8OZ6rRcF19nFj7cmzGfbebgcfU0LfPHx+HlZDh3A4S4QkngJIQFVRtNLNl2jPdXJ5JZpOYehXja8/TV4Vwb6YNWq6GkBA4cUL+7atOTdDq1SnSXLifzd00mdUQgMfHU6TVsbKgJDVWzgG1k+kQ0zMsLRo5Up+y2bFEXF2zerAbovXtrCAkJrlv7KTlZzYU6rfZTR29HFj+iBk+J2SWM/nQTCx6Kq7dwQYi2QAInISzAZFL4eU8GM1YdIiVPzT3ydTbw5LCO3NrDDyudlpwcdabkyJFTJ3Z1cFBzdSMiTubrGo2QnKbOs9RGVXq9GlUFBGDMz1fLTAtxHoGB6uxcYqI6hVdSAn/8oVan6NNHj+d5aj+FeDqw+JE+3PXZJpJzS7lj9kbmj48jyL3hulBCXKnkE1eIZqQoCmsSsnlnxSEOHlerfbvb2/D44FDu7h2IjU5Haqr63XR6ZW9fX3U6LjDwZHpSTQ0cTlXn7mrLChgMag2ewEB1SOq0AphCNIZGo87qhoSo03a7d6uvw++/V7fHxnpgP2jQqdpPOTmwdq2aOxcaSqC7HYsf7cPdn20iJa/MHDyFeTu29EMT4pKRwEmIZrL5SB7vrEhgW6p6VlZHvRUPXxXCA/3bY6O1IiFezcGtPQ9rbS3CqKjTThNXXQ2HU9RhqNrClba26heXrJITzcTKSl1lFxGhTt8lJqqVLI4cgehoLV27dsTq9NpPCQnq6rsePfBzsWfxo324d84WErKKGfXJRr5+MI5IP+eWfljiCjFo0CCio6OZOXNmSzelQRI4CXGR9qUX8vaKBP4+pGZ066203N83mEcHdsBasWHvTjV/qTYO0uvV6bguXdRSS4AaMB05ouaXVJ88NYq9vRow+flJwCQswt4eBg9WX4sbN6qx0bZt6uu1d297Qnr3VvOe9u5VV9/9/TdEReHl78/Ch3szdt7J1XafbmLeuNg6K0OFuFJJ4CTEBUrKLmHGqkP8uletSGml1TA6NoB/DQ1DU2Fgx6a6+UvOzuroUseOp6UlVVaqO6WkqNNzoK4nDwuTSt/ikvHygptuUmeGN28+lf/k6wv9+/vhMtBNLQ6Vl6f+m52Na1QU88fH8eAX29iSks89n2/mk3t7MrCjnDRaqKqqqrC5AheuSOAkRBOlF5Tz3h+H+G77MUyKGtvc1M2XJ4d1hBJ7Nq+tn7/Utas602aOgyoq1G+p1NRTJxpzclKjKjmXnGghHTqoZcB271arkGdkwHffQWSkLTE9+2CdmqRO26WnQ34+jj168OUDvXj0m+38dSiH8V9uZcboaG7o6tvSD0W0gEGDBhEZGYmVlRXffPMNUVFRfPDBBzz77LOsW7cOe3t7hg8fzowZM/Dw8ACgtLSUxx57jGXLluHo6MgzzzzTwo/i/CRwEqKRcksqmbUmifmb0qgyqonZwzp589SwjuiKndi8Wi2FA2fJXwK1lEBSkro2vDa528VFDZi8vS/p4xGiIbX5T2Fh6vRd7WKGpCQNvXuHEdrPQ11xV1YGGzZg27Ejn90bw6Qlu/llz3Ge+HYnReU1jIkLbOmHIlrAl19+yWOPPcb69espKChgyJAhjB8/nhkzZlBeXs7zzz/PqFGj+PPPPwF49tln+euvv/jxxx/x8vLiP//5Dzt27CA6OrplH8g5SOAkxHkUVVTz2d9H+PyfZMpOVvvuHeLGk4MjMJS6snPNqbOd2Nio+UuRkaflL4G6vDspSV3eXTt35+amBkwNnGhViJbm5AQjRqgx/oYN6qKGP/+Eg+1c6Rc3ELf0vXDsGCQkYJOTw3s3dcfJ1poFm9P4z/d7KSyv5rFBHVr6YYhLLCwsjLfffhuA1157je7du/PGG2+Yr587dy4BAQEcOnQIX19fPv/8c7755huGDh0KqIGXv79/i7S9sSRwEuIsyquMfLUxhY//OkzByWrfXf2deeKqcBzLPDj4j6ZOHndUlHo6FOvTz4NaVKROyaWnnwqYPDzUgKnOUJQQrVNgoLo+oXb67vhxWPqjFZGR3YmJ9MImfg/k56Nb9zevx0biYmvNR2sP89byeE6UVfHCNRFotTL13FbExMSY/797927WrFmDg4NDvf0OHz5MeXk5VVVVxMXFmbe7ubkRHh5+Sdp6oSRwEuIM1UYTi7Ye5f3ViWQXqzWUQr0ceLR3OB5V3iRt0Zhn2Vxd1ZOqhoaesfAtL08dYcrOPrXNy0ud/3CTlUfi8qLTQY8eary/YYO6lmHvXjhyxI9+3V0Jzt8BJ06g2bmT5wICcB0eyusrk/j07yPkllTy1m1dsdbJytC2wN7+VEHUkpISRo4cyVtvvVVvv3bt2pGUlHQpm9ZsJHAS4iSjSeHn3RlMX3WItHx17s3PxZZxPSLwM7Xj6D4N+Sf39fGB6OgzEr4VRc0KT0pSl26DemW7dmrW7WknTxXicuTgAMOHqzN0//yjDqiu/MeOoMB+9Pc7hH1GIhw9ykP29nhdE8yklaks25HOidIqZt3dAzsb+cppS3r06MHSpUsJDg7GqoEzHHTo0AFra2s2b95MYKCaE3fixAkOHTrEwIEDL3VzG01exaLNUxSFPw5m8+7KBOIziwFwt9dzd5dwgjS+5KXoOHpy3+BgdYSpTh537XnkDh9Wc5lAHX4KDFRLNNvLKSnElcXfH26/Xa1MsHs3pKZpSM8IJy7Mk07lO9CWlnKTJhnPqzx44J981iTkcPeczcy7PxYXuytvebpo2OOPP85nn33GXXfdxXPPPYebmxtJSUksXLiQOXPm4ODgwIMPPsizzz6Lu7s7Xl5e/N///R/aVl63TgIn0aZtOJzLOysS2JlWAKjVvm/pEEFHa3/KcnXkocZAYWFqwFRn0Ki6Wp2zSE4+dVoUa2v17PLBwWqlSyGuUFZWEBurTlOvW6cOtq4/6Ea800AGu+/BrSKDvtU5/NDDhnt3VLMzrYDbZ2/kywd64eciJwduC3x9fVm/fj3PP/88w4cPp7KykqCgIK655hpzcPTOO++Yp/QcHR15+umnKaxdntxKaRSlNmO19SoqKsLZ2ZnCwkKcnJya7bgmk4ns7Gy8vLxafYR7OWrN/bvnWAHvrEhgXWIuAAadjusDO9JZH4ixSv09YW2tJnufPMfpKeXlatHK02sw2dqqo0uBgZfspLutuX+vBNK/jaco6ilbNm069Rsi2v0o3a32Yq01cqykmkf2GtlvssPbSc8X43oR7u0g/WtBlnr9Wur7+HIiI06iTUnMKubdlYdYvl+tUGmFlmHtQulqF4SVYoOxSo2BoqLUsgJ1it42tELOyUn9yd2unZwWRbRZGg2Eh6vFMzdtUoOoXXkBHNa6cZX9dvwdCvkqysR/dmSxqsCDUbM38vE9PQiVcwOLy5AETqJNOJpfxsw/Evl+p1rtG6OWfu4hxDgG42CtB0VNfO3aVT3xaZ1Bo4ZWyHl4qAGT1GASwsxggEGD1NV369ZBYaE9vxb2p1NxAj1dkpge58q0DWksKfJm3BdbmTw8mLu9vFq62UI0iQRO4oqWU3yy2vfmVKqNCqZqLTGOwfRyCcbdTs2zcHKC7t3VPCbzoJGskBPigvn6qsnju3bBzp1aDpo6cTTTk352O3mhvz+eG1L5Ns+Bl38zUarY8MjADmjkNEPiMiGBk7giFZZX8+nfh5n7Twrl1UZMVToibPzp4xOCn7Na0tvNTQ2YQkJOKykgK+SEaBY6nXrqlpAQ+PtvyMryYFXVQDom7+aeHlpc9qexJC2Bd3+tIaOwgldGdkEnhTLFZUACJ3FFKauq4YsNKcxee5iiihpMlVYEKIEM8AomxENNqPDyUgOmwMDTAqazrZALDlZXyckKOSEuiKsr3Hgj7N8PW7bYEG8Vy/FjqfTy0mCrS2Zp4n6+X1tFRkE579/VXWo9iVZPXqHiilBVY2Lh1jQ++DOJnOJKjOXWeFX5M8AnmE4+Tmg0Gnx91YDJz++0G9aukEtLg5oadVsLrJAT4kqm0ajnbwwOVkefjhHEX2Uu+JSaGB9VwILdB9lTWc6dxZV8PjYWT0f5oSJaL/lWEJc1o0nhh53pzPjjEMdOlGMstcG5zI/+7YKI9ndBq9UQGKgGTHWKVhYXq/lLZ66Q69BBTdCQFXJCNDsHB7juOkhMhH/+cSS+oh/tC5IYHarHcPgQ8TtLuLW4grkPxBHmLUvuROt0Qd8Os2bNIjg4GIPBQFxcHFu2bDnrvvv37+e2224jODgYjUbDzJkzL7StQpgpisLyfZlcM/Nvnl6ym5SjJqwzfLnarjsTenalR6AroaEabrsNrrnmtKApLw+2bIG1a9XzRiiKukIuLg4GDlRLIkvQJIRFhYXBqFEQ2EFLdlAsufruDHPvQrfiEjz372L0+2v552SNNSFamyaPOC1atIhJkyYxe/Zs4uLimDlzJiNGjCAhIQGvBpaVlpWVERISwh133MFTTz3VLI0Wbdv6pFzeXpHA7qMF1BTrsT7hy1Xt/Ojb2x2DjY7QUPU8cuaFb7Ur5A4fhhMnTh2oXTu1pICskBPikrO1hQEDqigv17BhQziFts70NemxOp6M7aE9PPFxOc/f2Zs7ewW2dFOFqKPJgdP06dN56KGHGDduHACzZ8/m119/Ze7cubzwwgv19o+NjSU2NhagweuFaKydaSeYtjKB9Ul51BTrIdeH3j5+DOjrgb3BiogINWBycDh5g7OtkAsIUKfkZIWcEC0uKEjNO9y82YdE/SDi9LbYJCWjS0jk/S9KSc7rzfMjItDKijvRSjQpcKqqqmL79u28+OKL5m1arZZhw4axcePGZmtUZWUllbUrm1BLvINaQt5kMjXb/ZhMJhRFadZjilOaq38TMouZ8UciKw9kUVNkwJTjTQ/Pdgzq64mTrRWdOkG3biZzwGSqbOQKucv8eZfXr2VJ/1rW6f1rZQX9+kH79nb8/ecAuhocsD1gg7I/k7Vlf5KSVcy7d0bLirsmsNTrV94PTQyccnNzMRqNeNfJsgVvb2/i4+ObrVFTp05lypQp9bbn5ORQUVHRbPdjMpkoLCxEURQ5V5IFXGz/phdWMmdTBssP5lNdZKA6y5tOTm707+qMm70VYSHFdOlSg52dQlkZlOWVY5WWhvbYMTQnzyGnGAwYg4Iw+vmpK+Ra+ckjm0Jev5Yl/WtZDfWvlRUMGAw7nTvgbrKmxyETO+ILyS7awOjMfKbe1hkvR5vzHFmA5V6/xcXFzXasy1WrDN9ffPFFJk2aZP67qKiIgIAAPD09m/0kvxqNBk9PT/lgtIAL7d/sogo+XHOYRduOUp5voCrThwhXd67u7U07Vz2dO6unRrGzO3mDM1fIOTi0iRVy8vq1LOlfyzpX//r5QUaMG5t+8sVly0bWHcygdOVB/n2inOmPD6Sbv0vLNPoyYqnXr8FgaLZjXa6aFDh5eHig0+nIysqqsz0rKwsfH59ma5Rer0ffQMFBrVbb7B9gGo3GIscVqqb0b0FZFbP/OsK89cmU5umpzPSmg6Mrw3v7EOxpR5cuasBka3vyBnl5av5S7etRo1HPHdehg1rlsg2Q169lSf9a1rn6198fbnrIh20dh2Pz/QY27D6Mbm0a/8paznNPDWJkN99L3t7LjSVev/JeaGLgZGNjQ0xMDKtXr+bmm28G1Kh29erVTJw40RLtE21AaWUN89YnM/uvI5zIsqYq0wt/O2eG9/QhwtfBHDAZDKgjSsdlhZwQbYG1NfQZZk9Q+BAc5jqx/u+9sCeXmS+u5MBjcTx7vSSNi0uvyVN1kyZNYuzYsfTs2ZNevXoxc+ZMSktLzavs7rvvPvz8/Jg6dSqgJpQfOHDA/P/09HR27dqFg4MDoaGhzfhQxOWmssbIt5vVat+Zx6yoyvLAy8aR4dE+RAU6EhWlISrqZMBkMkGqrJAToi3yDdBx3X/iaBfuzspvNkBGAf+8uYGD8UXM+lcM9vpWmXUirlBNfrWNHj2anJwcJk+eTGZmJtHR0SxfvtycMJ6WllZnKC8jI4Pu3bub/542bRrTpk1j4MCBrF279uIfgbjs1BhNfL8znRmrEklN0VCV6Y6rlR03RXnTs70L3bppiIw8ufituhoSU+QcckK0cdbW0OvOUAK7OPPDu2tZvzeLkkU7uDmhnNmv9aKDj935DyJEM9AoSu35JlqvoqIinJ2dKSwsbPbk8OzsbLy8vGTe1gLO7N/aat/vLE8gIRGqspxw0NgypJMXfTu60r2blshIsLFBziHXCPL6tSzpX8u6mP6tLixj5ft/sfSXZMqrjRzzDuXZl+O4sa+bhVp7+bHU69dS38eXE/n2ERanKAp/H8rh7d8T2Lm/hqpMJwzoGdHRk0GdPIjpoaVLl5MBU3Ex7JdzyAkhzs7a2Y7r/zOcDl228PGsXWiyEnnvmSK23tuPyeP9sLaWvCdhORI4CYvam1HCZz8ks35HBVVZzlgbbRgU6smwKHfiYqzo0kUdgq+3Qg7Uc8i1oRVyQogm0OmIuLUPr0d48sFrqyE+i13zVnLX/j5Mf7EjgX66lm6huEJJ4CQs4uDxIt5ZnsCKTSVUZTqjrXakT3s3runmSb84azp3BmsrOYecEOLiOHQO5YX3XVj83u/8vCKfyo1rGftEEc//K5rhV+llkFo0OwmcRLNKyS1l+qpDLPv7BJUZLihV7sQEunJttDeD+tioI0w6Exw7phatlBVyQoiLpPHwYPT/3UFo2Cpmf5GIVcoW3vxfPrtv68dDdzrhJqlPohlJ4CSaRVZRBTP/SGTBqlzKjjthqvAgys+ZASH23DTCja5dtdhoGnkOOSGEaCqDgZh7rmdK0Bben7Ue7ZFD/PVVHklHBvL4Pf5066ZBI6lPohlI4CQuyonSKmb/dZjPfsui+Jgjpgp3wr0duW6gN9cMMODllY2/RwXapBRITZUVckIIy9Fq8R3Ym1cCfPj8g5/ZvDWLE2t/4X+Zfbjr1iiGD9PRRheCiWYk31jigpRW1vD5P8nM+imD/DQHTOVuBLnbc0M/b24c7EDXrmBVXkj+1n2wqwzzTz1HRzV/SVbICSEsxDYkmMf/ez/BX/zC0l9TqDr4N19+lkny0UHcMNxAp04t3UJxOZPASTRJRbWRBZvTmPH9MbKO2GEsd6Wdsy3XxXpz+zBHukUp6PPTYVsqppwcdIWF4OysrpALDZUVckKIS0Lj6MgNE0bhH/IPc79ch+bYAdYvziE7ZwRD+nlx1VWSTikujAROolFqjCaW7Ujnre9SOZpowFjmjLu9Ddf08WbMCBeiwyswZCXAurRT+UsaDUYvL+jVC8nOFEJccjod0dcP5P86+PPJ+99zOPEYycuXsjSrP5mZkQwYoEHO/CWaSgIncU4mk8Ly/Zm8tjiFpP3WGMuccDZYc3VPL+671oWYgDwMmVvhn9PqLxkMau5SQAA1RUVSVkAI0aK8IzrwwtRH+HrWUtZvSqVi3ypWZGVwonAQXSP19O9/8pyYQjSCBE6iQYqi8NehHF5bnMyeXTqMpfbY2egYGu3FA8Pt6eWVgSFrF+wuO3UjDw91hZy3t5q/ZDJBUVFLPQQhhDCzcXbkwRfuI3jZWpYs/puyvJ1sWpZDUeEIMjM9GTQI/P1bupXiciCBk6hne2o+ry48wuYtCsZSW/RWWgZ39uCxQVri3I9iW3Ackk3qztbWav2loCBwcGjZhgshxLlotQy9fQiBHQOY8/73ZGcdIWHFIvKiB1Fa2oXISA1xcbLQV5ybvDyE2YGMIv675DB/rqvBWKLHSqtlUKgT/+pTSZx7PIbqYsg/ubOLizq65OsLOjm1gRDi8hHWNYyXpz3GpzMWs29vGgUHfmPD8QwqqgaRnm7DkCHqALoQDZHASZCcW8rr3x3h59Xl1BQb0GqsGORnxcSepfTxTsNgbYRq1ADJz08NmJydW7rZQghxwRxcHHlq8v38tOhPfvvhHypLtrD1+0wiBl9LUZEnPXtCt25I0UxRjwRObdjxwnLe+iGZRb+XUFVgQKPYMNS9nEe6ldC3fRm2tid3dHBQgyV//5Nn5BVCiMufRqfjpjFX0yEiiM8//J7CE0eIXz2fvM7DMBq7kJamYfBgtfycELUkcGqD8kurmP7LEb74qYjyPAN2NSb8Kv8mwO4nnuk9iF7to9SfWe3aqQGTu3tLN1kIISwmskdHXp02gY+nLyYxPpUTh39ia9ZRug4awnff6enXDzp2bOlWitZCAqc2pKSyhg+Xp/DJ0hMUZesBAx5V++msfE6N90aMNmW8vmc9i6/ejD4kTM4dJ4RoM5zdHHn+v+NY9u2frPxxHdWVW9j263HC+tzA2mov0tKQsgUCkMCpTaioNjLnzzTeX5xLXroe0OPrYsvIATreSZ5Ah+MF5NlBqjNkOZSR7mNHiARNQog2RqPVctvdw+jYJZi5HyyjsCCFxH++JDd0OCZTVzIzNVK2QEjgdCWrMZr4Zn060xZkcTzVBhQ9ng567hrqwWO3ueHkVsmsaSb+sINqHWjQ4KR3xNfRt6WbLoQQLSYqOpRXpz3Gp+99R/y+ZIqO/ci23FS69BvOb78ZiIxUT4ggZQvaJnnar0Amk8Kybcd54+tMUpOsQLHBxdaa269y51+jPfDzrT25roFlo5Zx6+Jbqa4swlHvyLJRyzBYyVi0EKJtc3Z15JnJY/l56V/8+t1fVFdvZ9cf6QRG3wj4kZ4OQ4ZICmhbJIHTFURRFFbuzWHKl+kcOqhFMVlhr7fipj7uPHWXByFB9estDQ0ZStYzWWQUZ+Dr6CtBkxBCnKTRarnxjsFEdGnPnPeWkpd3nLSdX1CQPZTOPXrx/fdaYmOha1cpW9CWSOB0hVifkM8rXx5l125QjDoMVjqu6eXKs/d4ERF67qfZYGUgxDXkErVUCCEuLx07BzPl3QnMnfU9O7bGU5qznG1/JBPe63o2b3YiLQ0GD5aTJ7QVEjhd5nalFvLyF2ls3GJEMWqx0moZ2sOF5+/xoltnm5ZunhBCXBFsHWx5/PkxrF2+hSVfLaei6iAH1mXgE3EDitKR777T0K8fhIW1dEuFpUngdJlKzCzh5S/T+GNdFUqNFp1GR79IZ56/x5u4bnoZNhZCCAsYdE0vwrsE88mMJRxNyyL70EIKs+OIiBnCmjU2pKXBgAFgI79br1gSOF1mjuWX8+pXafz0ZznGKi0ajZbYMCeeu8eLQbF2aLXnP4YQQogL1y7Ai5ffeoSFX65g7YotVJZsYNeaFAK73gS0IytLTRz38WnplgpLkMDpMpFTVMn/FhxlyfISqiq0gJaoIHueudub6/o7SMAkhBCXkM7airvHX0/X7qF8+fGPnCjIIGXnXE5kDyOiayw//6yle3fo0QP5fL7CSODUyhWWV/PWoqN89XMR5aVqwBTazpZJd3lx+1BndPUXygkhhLhEomLCmfLuBL6Y9QM7dhyiJOs3tq45TGiPG9ixw4ljx9TRJyenlm6paC4SOLVSFdVGpi87xqfLCigu1ABaAj0NPHGHB/de64q1tSQxCSFEa2Dv7MDjL97NX8s38938VZRVxBO/IYPsDjdgMoWzdKlGznd3BZHAqZWpNpr4+LcMPliYR36eBtDg7WLDY7e488gtHtjYSMAkhBCtjkbDwGt70zmyPXM+WErSkUyKjyxkQ3YvonoOYe1aA0ePSuL4lUACp1bCZFL46s9Mps3P4fhxAA2uDtY8ONKNf93hib2dTJILIURr5xngzQtvPMwv367it182Q8UmdqxJwafzjSiKH1lZGgYPhnbtWrql4kJJ4NTCFEVh2YYc3vgqi5RUBQBHWx33XuPKM3d74+wgSUxCCHE50VhZMfLea4nqHsYXH/3I0exM8vZ/yV8ZA4mN7c0vv1gRHQ0xMZI4fjmSwKkFrdyZz3/nZXDwkAkAg7WOUcOcefFeH7zc5KkRQojLWXBkKC+98xjLPv+ZP9YdoKZkFev+SKZ91+tQFHfz+e4kcfzyIt/OLWBzQiEvf57O9j01AFjrtIwc4MTL9/sQ6COT30IIcaWwsrdj1BOjiO6xi6++WI6mIJH0nXNJTR/BgB6dWbrUShLHLzMSOF1Ce1OKeXluOuu2VoECOo2GYXGOvHK/D+HBcnJdIYS4Imk0dOzfnZfCA1k25yf+3J6MMf97fl+ZTET3AWQUGOmR4syQgTbo9S3dWHE+EjhdAoczy5g87xgr15VjMmnQaKB/Nwcmj/OhR4RdSzdPCCHEJWDwdGfMs/cSvXI933y3Hk3hdlK2HuMbkz2lf+/jqQP388ToSEkcb+UkcLKgjPxKpnx5jB/+LKGmWi0tEBNux8sP+DCgm5xGWwgh2hwrKzpfN5DnOvoyYfJTuGm6c22VgW1lfXlvzW/4G8KJjbGWxPFWTAInC8gvqea1b46x8PdiKisBNHQKNvCfsV5c18elhVsnhBCipeW76/ih/a/EZRwgqPg6DAEhOJ4YwMKtKVTXtCc93UoSx1spCZyaUWmFkbcXpzPvxwJKS9Vt7X31PHe3J3cMcUMjtSuFEEIAvo6+WDs68VdQMh6ln1FjU4Wj40gOF5Tz3toqbu4awIkTTpI43gpJ4NQMKqtNfPBDBh9/d4KCQrUWk6+HNf8e7cG46zzQ6SRiEkIIcYrBysCyUcu4dfGt5GiKcNIv4sWr7mDRBi2H7Y7yzZ4yoo56U1Diy9GjVlJxvBWRwOkiGE0Kc37PZOa3uWTnqgGTu5MVE253Y8It3tjI+eSEEEKcxdCQoWQ9k0VGcQa+jr4YrAyM7Wlk+qoE5qxL5mBWBUl/lHBDti9ZWc4MHarB27ulWy0kcLoAiqKwcG0Ob3+dQ1qGEQAnex0PjHRl0mgf7G0lo08IIcT5GawMhLiGmP+2tdHxf9d35vquvjz/3R4OHEln8e5Kdh9zJSPXjyH9reneHUn9aEESODXRr5vz+N+8LBJT1OKVtnotd41w5j/3tsPVUbpTCCHExYsOcOHnJ/rz0dokPvzjMImplcxYWcqBDB9uOurG0KEaHGRxdouQb/pG+mtvIVM+P87u+CoAbKy03DrUkZfu86Wdu3ULt04IIcSVxsZKy5PDOnJtZDueX7qHrbtz+GlPDbuPFpCQ5seokQaCg1u6lW2PBE7nsT2xmFfmZrBxZyUAOq2Ga/vZ8+oDvrRvJ9W+hRBCWFa4jyNLH+vLVxtTePOnJI4mVvPu7+VsP+LJwzd5MLC/Div5Nr9kpKvPIj6tjMlz0/lzczmKos4nD4qx59UH2xHZXqp9CyGEuHR0Wg3j+rXn6s7e/N+yfaz8q5A/DprYfayAsft9eeQuR9zcWrqVbcMFZTHPmjWL4OBgDAYDcXFxbNmy5Zz7L1myhIiICAwGA1FRUfz2228X1NhLITW7ggfeOsxVjyWxepMaNMVF2fLruyF891oHCZqEEEK0GH9XO754IJZPnm6PX1QBuRXlTPs5mXteOsrGrdUt3bw2ocmB06JFi5g0aRKvvPIKO3bsoFu3bowYMYLs7OwG99+wYQN33XUXDz74IDt37uTmm2/m5ptvZt++fRfd+OZ0NLeCx2cm0/vBRH5cU4rRCF3D9Cx+PYjf3gkjrrNk4QkhhGh5Go2GG7v58veU3tw/RoeVUwWbj5zgztcSeWVWLuXlSks38YqmURSlST0cFxdHbGwsH374IQAmk4mAgACeeOIJXnjhhXr7jx49mtLSUn755Rfztt69exMdHc3s2bMbdZ9FRUU4OztTWFiIUzPWnzeZTKzfm8pnK6tY8XfFyfPJQYdAa/5znzc395dxz4thMpnIzs7Gy8sLrZx0qdlJ/1qW9K9lSf82ny3J+Twx6zBJ+/WgQIS/He/8y4cQr5Jm719LfR9fTprUm1VVVWzfvp1hw4adOoBWy7Bhw9i4cWODt9m4cWOd/QFGjBhx1v0vld1phdz+xgFu+b9Cfl1dSU21ho4Bet5/ph2bP4mQoEkIIcRloVd7N/5+swfPPmSPjZ2R+GNl3PJCClO+LqS8ytjSzbviNCk5PDc3F6PRiPcZpUu9vb2Jj49v8DaZmZkN7p+ZmXnW+6msrKRSPTsuoEa4oP5CMZlMTWnyWf29uYK//jGhQUu39vZMHOXGTVc5o9GoBS6bOBAnGmAymVAUpdmeM1GX9K9lSf9alvRv87LWanju5vbc2qeUiTPS2L7HyOLVlaA7xqwng5rtfuT5aqWr6qZOncqUKVPqbc/JyaGioqJZ7uOGWIW/NtlzTc9qrhlgi5VVJTk5DedpiQtjMpkoLCxEURQZircA6V/Lkv61LOlfy3DSwJdPuTF/bTFzfynn4Wt0Z81BvhDFxcXNdqzLVZMCJw8PD3Q6HVlZWXW2Z2Vl4ePj0+BtfHx8mrQ/wIsvvsikSZPMfxcVFREQEICnp2ezzqkufMtETk4Onp6e8sa1AJPJhEajkf61EOlfy5L+tSzpX8t68g5P7rwqGx/v5s1xMhikfmGTAicbGxtiYmJYvXo1N998M6C++FevXs3EiRMbvE2fPn1YvXo1Tz75pHnbqlWr6NOnz1nvR6/Xo9fr623XarXN/gbTaDQWOa5QSf9alvSvZUn/Wpb0r2VZ6bTN3r/yXF3AVN2kSZMYO3YsPXv2pFevXsycOZPS0lLGjRsHwH333Yefnx9Tp04F4N///jcDBw7k3Xff5frrr2fhwoVs27aNTz/9tHkfiRBCCCGEhTU5cBo9ejQ5OTlMnjyZzMxMoqOjWb58uTkBPC0trU5E2rdvXxYsWMBLL73Ef/7zH8LCwvjhhx+IjIxsvkchhBBCCHEJNLmOU0uwZB0nqSNiOdK/liX9a1nSv5Yl/WtZlupfqePUSlfVnak2tqstS9BcTCYTxcXFGAwGeeNagPSvZUn/Wpb0r2VJ/1qWpfq39nv4MhhzsZjLInCqXf4YEBDQwi0RQgghRHFxMc7Ozi3djBZxWUzVmUwmMjIycHR0RKPRNNtxa8scHD16tM0OOVqS9K9lSf9alvSvZUn/Wpal+ldRFIqLi/H19W2zI4WXxYiTVqvF39/fYsd3cnKSN64FSf9alvSvZUn/Wpb0r2VZon/b6khTrbYZLgohhBBCXAAJnIQQQgghGqlNB056vZ5XXnmlwSrl4uJJ/1qW9K9lSf9alvSvZUn/Ws5lkRwuhBBCCNEatOkRJyGEEEKIppDASQghhBCikSRwEkIIIYRoJAmchBBCCCEaSQInIYQQQohGksBJCCGEEKKRJHASQgghhGgkCZyEEEIIIRpJAichhBBCiEaSwEkIIYQQopEkcBJCCCGEaCSrlm5AY5hMJjIyMnB0dESj0bR0c4QQQog2SVEUiouL8fX1Rattm2Mvl0XglJGRQUBAQEs3QwghhBDA0aNH8ff3b+lmtIjLInBydHQE1CfKycmp2Y5rMpnIycnB09OzzUbOliT9a1nSv5Yl/WtZ0r+WZan+LSoqIiAgwPy93BZdFoFT7fSck5NTswdOFRUVODk5yRvXAqR/LUv617Kkfy1L+teyLN2/bTltRl6tQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETkIIIYQQjSSBkxBCCCFEI0ngJIQQQgjRSBI4CSGEEEI0kgROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETkIIIYQQjSSBkxBCCCFEI0ngJIQQQgjRSBI4CSGEEEI0kgROQgghhBCNJIGTEEIIIUQjSeAkhBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgXFDjNmjWL4OBgDAYDcXFxbNmy5az7fvbZZwwYMABXV1dcXV0ZNmzYOfcXQgghhGitmhw4LVq0iEmTJvHKK6+wY8cOunXrxogRI8jOzm5w/7Vr13LXXXexZs0aNm7cSEBAAMOHDyc9Pf2iGy+EEEIIcSk1OXCaPn06Dz30EOPGjaNz587Mnj0bOzs75s6d2+D+8+fPZ8KECURHRxMREcGcOXMwmUysXr36ohsvhBBCCHEpNSlwqqqqYvv27QwbNuzUAbRahg0bxsaNGxt1jLKyMqqrq3Fzc2taS4UQQgghWphVU3bOzc3FaDTi7e1dZ7u3tzfx8fGNOsbzzz+Pr69vneDrTJWVlVRWVpr/LioqAsBkMmEymZrS5HMymUwoitKsxxSnSP9alvSvZUn/Wpb0r2VZqn/l+Wpi4HSx3nzzTRYuXMjatWsxGAxn3W/q1KlMmTKl3vacnBwqKiqarT0mk4nCwkIURUGrlQWGzU3617Kkfy1L+teypH8ty1L9W1xc3GzHulw1KXDy8PBAp9ORlZVVZ3tWVhY+Pj7nvO20adN48803+eOPP+jates5933xxReZNGmS+e+ioiICAgLw9PTEycmpKU0+J5PJhEajwdPTU964FiD9a1nSv5Yl/WtZ0r+WZan+PdegR1vRpMDJxsaGmJgYVq9ezc033wxgTvSeOHHiWW/39ttv8/rrr7NixQp69ux53vvR6/Xo9fp627VabbO/wTQajUWOK1TSv5Yl/WtZ0r+WJf1rWZboX3muLmCqbtKkSYwdO5aePXvSq1cvZs6cSWlpKePGjQPgvvvuw8/Pj6lTpwLw1ltvMXnyZBYsWEBwcDCZmZkAODg44ODg0IwPRQghhBDCspocOI0ePZqcnBwmT55MZmYm0dHRLF++3JwwnpaWVici/fjjj6mqquL222+vc5xXXnmFV1999eJaL4QQQghxCV1QcvjEiRPPOjW3du3aOn+npKRcyF0IIYQQQrQ6MlkphBBCCNFIEjgJIYQQQjSSBE5CCCGEEI0kgZMQQgghRCNJ4CSEEEII0UgSOAkhhBBCNJIETkIIIYQQjXRJT/IrhBDi8lVeZWR9Ui570gvpGeTKgDAPNBpNSzdLiEtKAichhBBndTS/jDUJ2fwZn83Gw3lU1pjM14V42jO2TzC3xfjjoJevE9E2yCtdCCGEWY3RxPbUE/yZkM2a+GwOZZXUud7PxZZuAc78fSiXIzmlvPLTft5ZkcAD/dvz1LAwGYESVzwJnIQQoo3LL63ir0PZ/Bmfw9+HcigsrzZfp9NqiAl0ZXCEF0M7eRHm5YBGo6G4opplO9L5cmMKR3JKeX91Ioqi8PTw8BZ8JEJYngROQgjRxiiKwoHjRayJV6fgdh4tQFFOXe9iZ82gjp4M6eTNwDBPnO2s6x3D0WDN2L7B3Ns7iG82pzL5x/188GcSPs4G7o4LuoSPRohLSwInIYRoA8qqaliflMef8eoUXGZRRZ3rI3wcGXJyVCk6wBWdtnFTblqthvv6BJNXUsV7qxN5+Yd9eDsaGNbZ2xIPQ4gWJ4GTEEJcoY7ml/FnfDar47PZdCSPqtMSu22tdfQLdWdwhBeDw73wdbG9qPt6clgYmYUVLNp2lInf7uDbh3rTPdD1Yh+CEK2OBE5CCHGFqDaa2JZywrwKLim7bmK3v6stQyK8GBLhRe8QdwzWuma7b41Gw2u3RJJVXMHahBwe/HIbSx/rS3sP+2a7DyFaAwmchBDiMpZXUsnahBz+TMjm70M5FFfUmK/TaTXEBLky9GSwFHoysdtSrHVaZo3pwZ2fbmJveiH3zd3M0sf64uVosNh9CnGpSeAkhBCXEUVR2J9xMrE7IZtdZyR2u9nbMKijJ4MjvLjqLIndlmSvt2LeuFhu+3gDqXll3D93K4se6Y2j4dK2QwhLkcBJCCFaudLKGtYn5Zqn4LKKKutc37mdE0MivBgc4UV0gEujE7stxcNBz1cP9OK2jzdw4HgRj3y9nXnjYtFbNd/UoBAtRQInIYRohVLzSvnzZLmAzUfyqTLWTezuH+ahBkvhXvg4t76psCB3e74Y14vRn2xkw+E8Ji3ezQd3dkfbwkGdEBdLAichhGgFqo0mtqbkm2srHc4prXN9gJstQyO8GRzhRVx7t2ZN7LaUSD9nPrm3J+O+2MKve47j6aDnlZGdpbq4uKxJ4CSEEC0k92Ri95r4k4ndlacSu620GnoGu5pXwXXwtGxit6X0D/Ng2h3d+PfCXXyxIQV3exueGBrW0s0S4oJJ4CSEEJdIbWJ3bW2lPcfqJna729swMNyTIRFeDAjzxNn2ykiovinaj/zSKqb8fIB3Vx3C1d6GMb0CWrpZQlwQCZyEEMKCSipr+CcxlzXx2axJyCa7uG5id6SfE0PC1cTubv4uV2wO0Lh+7ckrqeLDNUm8/OM+XGyt6Ond+qcbhTiTBE5CCNHMUnLVxO41CWrF7mrjqWElOxsd/UI9GHpyFZy3U+tL7LaUp4d3JK+0im+3pDFp8W7evSmU6728WrpZQjSJBE5CCHGRqmpMbEvJV1fBJWRz5IzE7iB3OwaHq7lKcSFubXZZvkaj4bWbIykoq+L3fZk8//Nh/H086B7o1tJNE6LRJHASQogLkFNcyZoE9YS56xJzKTkjsTs22I2hndRRpRAP+8sysdsSdFoNM++MpmDuVjYeyWPcvG0sebQPYd6OLd00IRpFAichhGgEk+lUYvef8VnsPlZY53oPBxsGdlRHlQZ09MBJKmWfld5Kxyf39uDO2es5kFXGPZ9v5rtH+xLgZtfSTRPivCRwEkKIsyitMrJ8XyZrD+WwJiGHnDMSu6P8nBl8slxAVz/n8yd2KwpUVoLRCDodWFur/zaDipoKMooz8HX0xWDV+vOmHPRWzLg5jCe+P8yh7BLu+XwzSx7tI+e1E62eBE5CCHGa5JOJ3X8cOM7WlBPUnCrYjb1N3YrdXqcndldVQUXFuS+VlfXvUKNRgycrq6ZfTgZfa46u4/bv7yS/uhgngxPLRi1jaMhQy3fWRXK2teLLB2K545NNpOaVcd/nW1j0cJ9Lfn49IZpCAichRJtWVWNiS3K+eRVccm7pGXukc0OoJ/dEdaa7twF9TTVUFMGh7LoBkcnU4PHrqQ2UatScKJNRoaq8hqqqGior1firqkq92mhU/z39/7V1nxRFvVSbqpm1+X36mjpj0hgp1Ot4YctrTLsjGFsvL2zcHDDYarC1BVtbcHRU/20tvJ0MzB8fx+2zNxKfWczYeVv4ZnwcDnr5ehKtk7wyhRBtTnZxBWsTcvjzYDb/JJ1K7NbXVOFbWYKhcgf6iu2EWpVxtGInOcf19PD4Gptsm3MfWK9XLwYDGAwoegPlioFSo4Hi6pOXShtKSjUUV0BZsZHq8hq0pho0phq0xpP/N55lm1J/W3FZLuVlBrTo0QKu5UABZK3eiJPeGUVnRZWtM1W2zlTaulBl5wL29jg6qkGUqyu4uYG7O7i4gFZr2b5vSJC7PV8/2IvRn2xi19ECHvpyG/PGxV4Wp5URF05RFIxGI1ZWl1cocnm1VgghLoDJpLA3vdA8qrTnWCEoCg5V5bhUFNNNU8lVHjp6+ulxd67gieUz0aLB2iYUBYVCYzm52gp8Pf3qBEa1lwoMFFboKSzWUlAAhYVQeFT912g8V8t0YK1D0ejNI0K2tuph9Xo1BerMi1arDlrVXiqNFTw8ewql5WXYVmlxKdfia7KlSx8/dIXlVFfUUFWVR1VVHpXF6gCZSWdNlZ0LhXYu5Ni6UGXrjNHGFq1WDaS8vdWLj48aXF0KET5OfPlAL+7+bBMbj+QxYf4OPrk3BmtdC0Ry4oJVVlby7LPPsnDhQoqKiujZsyczZswgNjaWtWvXMnjwYH777Tdeeukl9u7dy8qVKwkICGDSpEls2rSJ0tJSOnXqxNSpUxk2bJj5uMHBwTz88MMkJSWxZMkSXF1deemll3j44YfN+2zYsIEJEyYQHx9PZGQkL730Erfccgs7d+4kOjoagH379vHss8+ybt067O3tGT58ODNmzMDDw6PRj1ECJyHEFam4opp1ibn8GZ/N2oQc8ovKcK4owaWihO7lxXRzUOju60BXf2eC3DzUxG6Nhkp7Azle9mToyjnh6cimcg22to64XXcbVSYD+fmol3T13xMnGk5dqqXRgL29GoA4OJz6t/Ziaws2Nup+F8bADw9/wK2Lb6WosggrvRNvjlpGl5DB6lxeSQkUFJgvxhNFVJRVU16eQ1lZDiUlUJwJhRV6Sq3VEankZGfibV0wWeuxswM/PwgIAH9/NaizlOgAFz6/P5axc7fwZ3w2Ty3axXt3dkd3hVZTvxI999xzLF26lC+//JKgoCDefvttRowYQVJSknmfF154gWnTphESEoKrqytHjx7luuuu4/XXX0ev1/PVV18xcuRIEhISCAwMNN/u3Xff5X//+x//+c9/+O6773jssccYOHAg4eHhFBUVMXLkSK677joWLFhAamoqTz75ZJ22FRQUMGTIEMaPH8+MGTMoLy/n+eefZ9SoUfz555+NfowaRTn9TEmtU1FREc7OzhQWFuLk5NRsxzWZTGRnZ+Pl5YW2Jcanr3DSv5Yl/VuXoigcyS1lTXw2f8ZnsysxE4fSIlwqinGpKMHTVEmXdo5E+TsT5e+Mi62NmmDt6npqvsrVFays+OPwam776kGCarqTXFDIf3q+S5C+OyUlZ79/e3t1qsvZ+dS/zs5qcHQpnp5Gr6ozmaC4uE4wRXExKArl5VBYBAUn1M355bZUGFyotHej1MUPk7UeLy8IDISQEPVxXqhzvX7XJmTz0FfbqDYqjOrpz5u3dr1iT0VjKZb6fDjX93FpaSmurq588cUXjBkzBoDq6mqCg4N58skniY2NZfDgwfzwww/cdNNN57yfyMhIHn30USZOnAioI04DBgzg66+/BtT3u4+PD1OmTOHRRx9l9uzZvPTSSxw7dgzDyeh+zpw5PPTQQ+YRp9dee41169axYsUK8/0cO3aMgIAAEhIS6NixY6P6QEachBCXrcoao5rYfTCLzbtTKMrIxrm8GOeKEvrUVOLjZCDK35mufv6EeTtg7WB/KkBycwMnJxQ0FBRAbi7kJKr/5uYO5XXvBLLys/H288KmWk9JtXqf9icPUZsX5OqqBkgtnaZhsDIQ4hpy/h212lNRXVCQus1ohKIibAsKsC0owKegAEpKMBrLKSgoJzf3ODnHDpKla0dhaTDbst3Ytk3tg5AQ6NBBPVxzGRTuxft3dufxBTtYvO0YBmsdU27sIkVEW7nDhw9TXV1Nv379zNusra3p1asXBw8eJDY2FoCePXvWuV1JSQmvvvoqv/76K8ePH6empoby8nLS0tLq7Ne1a1fz/zUaDT4+PmRnZwOQkJBA165dzUETQK9evercfvfu3axZswYHB4cG2y6BkxDiipRdVMGahGz+2Z1K/J4j2BXk4VpeTDvFSIBWQ0dvR6I6edM1wAUfP89TUY6bG4rBlsJCyMmB3AMn/801L3Crw2BjTQd/B9q3t8bD49Rh9PpL/5gtTqc7NfJWq6YGXWEh7gUFuGdkEF5QQEVFOrm56WQUOHLEFMwJoz/b8q3Ytk3NiQoPV4Mo62aoJnBtVDum3dGNp5fs5quNqRisdbx4bYQET1cAe3v7On8/88wzrFq1imnTphEaGoqtrS233347VVVVdfazPuOFpdFoMDV2NStqgDZy5Ejeeuutete1a9eu0ceRwEkI0aqZTAq7jxWwdv9xtu9IJPvIMdzLCrGrriAQcLa1JqqDK1FB7nTuEoSdt6d5VKmixorsbMg+Dlm7IDsbqqvr34eVFXh4qBdPT/Xi6Ag5OZV4ebXMSrMWZ2WlDqm5u6vRUGEhhpQU/O3T8TcW0716L1m5B0ip8SepJpisLCeysmDDBnX3zp3VfrwYt/bwp6LaxH++38unfx/BYK1j0tWNGxUQl16HDh2wsbFh/fr1BJ0czayurmbr1q318o1Ot379eu6//35uueUWQA1wUlJSmnTf4eHhfPPNN1RWVqI/+etm69atdfbp0aMHS5cuJTg4+KJW8kngJIRodYoqqll3KJf1O5PZvzsJbU4OLhXF6BUTAUB7d3u6BvjTJTKY9p3bo/X2wuTgxIkCDSlZkL0fsrLUVW1nqo0HPD1PBUouLvWTs5vwQ7ZtcHaGbt3UiOjYMaxTUvC3LsGfVGIrU0krduVgeTCZJl8SErQkJKijUFFREBx84cHnmLhAKmuMTPn5AO+vTsRgrWXCoNBmfWiiedjb2/PYY4/x7LPP4ubmRmBgIG+//TZlZWU8+OCD7N69u8HbhYWFsWzZMkaOHIlGo+Hll19u0kgSwJgxY/i///s/Hn74YV544QXS0tKYNm0agHmU8vHHH+ezzz7jrrvu4rnnnsPNzY2kpCQWLlzInDlz0DWyir8ETkKIFqcoCodzSlm7L4Nt2xM5mpCCS0kBhppKPABbKx1dAp3pHOJNVI+OuLX3p8LBg6w8K7ZlQfYhdTSpoSk3Fxfw8lK/xL281NmoNjmC1FysraF9e/WSlwcpKeiPHydMf4IwTpBfsp/EigAOlgWRlWVPVpaaIB8ZCZ06Xdg03rh+7amoNvHW8njeXp6AjU7L+AGNyOcSl9ybb76JyWTi3nvvpbi4mJ49e7JixQpcT58GPsP06dN54IEH6Nu3Lx4eHjz//PMUFRU16X6dnJz4+eefeeyxx4iOjiYqKorJkyczZswYc96Tr68v69ev5/nnn2f48OFUVlYSFBTENddc06QEellVJ6uSLEb617Iu9/6trDGy+Ug+63ccYc+ORCozMnGpKEaD+pHk42QgKsCVzpHtiegWSpWTD5klDhw/DpmZahmAM1lb1w2SvLwufPn85d6/l1RlJaSlQWoqlJebNx0p9mRvcTAFem/QaNDr1RGoyEiwsmp6/85YdYj3VicC8N+bunBfn2BLPaLLXkusqmtt5s+fz7hx4ygsLMS2Gcvly4iTEOKSySysYO3+dLZvSeDwgWTsC/OxMVZjBzhptYS3c6RzWDu69gjDziuY41XuHM/W8d02GiwF4OJyqlhj7WiS5A63AL0ewsIgNFSdI01NRZ+dTSd9Dh1dc0jPM7CvOIjj1YFs22Zgzx519Mnbu2l38+SwMKqNJj5ae5jJP+7HSqtlTFzg+W8o2oSvvvqKkJAQ/Pz82L17t7lGU3MGTSCBkxDCgownE7vX7Upl75YDFKQcw6miFA0KrpxM7A70JrxLCAHBYRTofDleaMcfR6DiQN1jaTRqTlK7dmpFax8fyxZjFBdAozn15JSVQWoqurQ0Ar0qCPBMIDPrEAfyfThmHczOnW5UVNjSrx9ERzduCk+j0fDsiHBqTAqf/n2E/3y/FyuthlGxARZ/aKL1y8zMZPLkyWRmZtKuXTvuuOMOXn/99Wa/H5mqk6F4i5H+tazW2r+F5dWsS8xh7b50Dm5PwJB1HJeKYgA0QHsPe8JD/Qhs3xEbl/akl7mTlaOtl59kZaWOIvn4qMGSl1fzLHNvrNbav5cdkwmOH4eUFMjPR1EgKxvij9pyqNITJbAztg7WxMSoo1CN6WpFUfjvLweYtz4FjQam3d6N22L8Lf5QLicyVWc5MuIkhLgoiqKQlF2ingfuQCYpB5PxKszBvawQH8V0MrHbDf/AENwDO1Ok9Scj38CuPCDv1HH0enXqpl079eLhIUncVwStVj1ni58fFBWhSU3Fx/oYXp6ltEvMJD3tOFlO4awvC2LvXi09e6rlDM415arRaJh8Q2dqjApfb0rlme92o9XCLd0leBKWJ4GTEKLJKqqNbD5ZsfvP+CyKM7JpV5yLV8kJuphq8HE00DHQG2+PQKw9OpKuBHAcA8dzTx3DYABf31OBkuQntQFOTmp2eKdOkJaGZ9V2QkMrSU/fx6HkJLJdOvJnQQD79mnp1+/cdaA0Gg1TbuyCUVFYsDmNpxfvRoOGm7v7XbrHI9okCZyEEI2SWVjBnyfPA7c+KRdtSTE+xXkEluThYKwmxMWFIN8A3B28KLYNodDBjzRbJ04ukkOvPxUo+fpKoNSmWVlBcDBVBgOaykoC7ZPw9a0gNXUPiYeTyCvoyPdZ/oRHaOjVSz0RckO0Wg2v3RSJosC3W9KYtHgXGg3cFC3Bk7CcCwqcZs2axTvvvENmZibdunXjgw8+qHdOmFr79+9n8uTJbN++ndTUVGbMmHHOCqJCiNbBaFLYdbTAfNLcA8eL0NdU4V2cR1RRLr5GhRAnV3zc2+Ng5UyZkz+lrv4k27uBRoONDQT7ngqW3NwkUBJn0GrV8+UFBWGVmkoH+0T8/cs4dGgXqQmJHC0IJ/mILz1iNERGNjx1q9VqeP3mSBRFYeHWozy1aBcgwZOwnCYHTosWLWLSpEnMnj2buLg4Zs6cyYgRI0hISMDLy6ve/mVlZYSEhHDHHXfw1FNPNUujhRCWUVhWzV+JOayJz+avQznkl1ahMxnxKsmne/4JuqDB39YZN4dQHPUGKpy8KXH1p8DRGxuDFh8fNVDy9VWrc0ugJBpFq1ULagYGok9JIcoxiYDsUg4e3EFudiK7c8OJP+hD/wEafH0burmGN26JApDgSVhckwOn6dOn89BDDzFu3DgAZs+eza+//srcuXN54YUX6u0fGxtrPiNyQ9cLIVpObWL36pOjSttTT2A0KWgUE25FxXQ/UUoMCj7W9ng4BWOwtqLS3o1SV3+yPHzxCbAm5OTUm4eHBEriIul0amZ4UBAuycn09jhMekoxhw5tozTLidVHIwiM9SYurn4pitrgSVFg0TY1eDIpiiSMi2bXpMCpqqqK7du38+KLL5q3abVahg0bxsaNG5utUZWVlVRWVpr/ri29bjKZmnz+mnMxmUwoitKsxxSnSP9a1oX2b0W1kU1H8lmTkM2ahByOnVArPSsmDYZ8I7EV5UTXVOFjZYOnqydajYZqvQNlbv7oOvrh18EOX19Onvz21H0rinq5Usjr17LO2b9arRpABQbie+QIXr5HOHSggKNHNnHiuAvf746gxwhPwsLq3/T1m7ug1cC3W48yafFuaowmbuvR9oInS71+5f3QxMApNzcXo9GI9xnlXr29vYmPj2+2Rk2dOpUpU6bU256Tk0NFRUWz3Y/JZKKwsBBFUaROiwVI/1pWU/o3q7iK9cmFrE8uZNvRIiprFBQFTGU2aEsdiampIaqiiFDrUuxtdGBthdHKmnIfLxw7tcOvgz1eXiasrUsAtYR3bu457/KyJ69fy2p0/7q6QvcovF1TcNh3jEMHyzDtPM72BFd2R4bSfZgDjo51I/Yn+npSWVnBsj05PPfdXgoKixjZxcPCj6h1sdTrt7i4uNmOdblqlavqXnzxRSZNmmT+u6ioiICAADw9PZu9AKZGo8HT01M+GC1A+teyztW/RpPCzpOJ3WsScojPVD/sjBVWGIvtcTI50tnGgZ7WBXS2y0NvqgIHDQZbR5zCvHGNDsI70hNbu7Y79yavX8tqcv/6++MeW4n/oSRS1qZwOLEC0959HEj1oMP1EXTq61pnqvid0V7Y2x3g601pvL4qFXsHR+5sQxXGLfX6NUi5/qYFTh4eHuh0OrKysupsz8rKwsfHp9kapdfr0ev19bZrtdpm/wDTaDQWOa5QSf9a1un9W1BWxV+HTiV2nyirxlSlw1hiwFTijr+NG6FuzvTwLadDdRZ2xQlYW6lJ3G6+drhFB+LQJUjOY3Iaef1aVpP719YWbbcoQsPD8NmZyMEVaeTl5HNs4QbyN3nRbXQEzoHO5t3/e1MkOq2WLzak8J/v91FjUtrUiYEt8fqV90ITAycbGxtiYmJYvXo1N998M6BGtatXr2bixImWaJ8Q4iwUReFwbjlLDx5mbUKOmtht1GAs0WMstsemwp4Ozm5E+DjSKcIGr9IMnAr34aUtw/3kqjfHEE80wUFqyW75QBSXC4MBhz5RxEaHkrziEElrjlKWks3md7Jp38eH0OvD0Tg7odFoeGVkZ6x1Gj5bl8zkH/dTVWNi/ICQln4E4jLW5Km6SZMmMXbsWHr27EmvXr2YOXMmpaWl5lV29913H35+fkydOhVQE8oPHDhg/n96ejq7du3CwcGB0NDQZnwoQlz5KqqNbDicay5EmVFQgbHcGmOxgZpiLzy1zoR7OxLeyYlAN1vsyk4QYErGX3Mc9wATLlGgM1hDQAAEB4O9fUs/JCEunK0t7W/uhmefUHYtPkRJ/DEOr88k70AWXW4OwzGmIxqNhv9c1wkbKy2z1hzmtV8PUmU0MWGQfP+IC9PkwGn06NHk5OSYz0AcHR3N8uXLzQnjaWlpdYbyMjIy6N69u/nvadOmMW3aNAYOHMjatWsv/hEIcYVLLyhXzwN3smJ3eTkYiw0Yi+3RlLrT3tWZCB9HwqMccbXX42hbQ4jNMQKMKXh4FmNjc/JALi5qsOTrqy77FuIK4eBtT/8nupOwPYyEH+MpyDvOxi8PEXogh/a39UBjb8czw8Ox0emY8cch3l6eQFWNiX8PDUMjNTREE2kUpfUvILbU2Zjl7OeWJf17YWqMJnYeLTAHSwczijGW6jEW21JTbMAJO8J9HOno7YiXQcHLwwl/fy2BLkX416TgVHQMjEb1YDqdenLV4GBwdj7n/Yq65PVrWZbq35IS2Lwsncpte9Eaq3H3tiJyTFdsQ9VimB+tTeLt5QkAPDqwA89fE35FBk+W6l9LfR9fTlrlqjoh2praxO7VB09W7M6vHVUyYCp1IcDVnnAfRzpFOeLtZMDTU4OvrwmDTTZdXIuwTk+DnBOnDujgoAZL/v5gbd1ij0uIS83BAYbe58fBSDcOL9lBXlY+Gz7cQfjQbPyvjWLCoFD0Vjr+98sBZv91mIpqI5Nv6IxWe+UFT8IyJHASogUoikJCVjGrD6qjStuOFFJdZDDnKhmwJsLbkYgIR8K8HPF0tcLfH/PFUFmIKS2Ngr170dnbq4ndWi34+KgBk7t7Sz9EIVpUpx62tGvfly3zE6mOP8S+5cfIPZRP53t68GD/9histbz0wz6+2JBCeZWRN26NQifBk2gECZyEuETKq04ldq85mENauunkqJItxnI/fJwMhPs4EhHpRHsvW/z9tOZAydUVKC+HY8dgUzoUF4PJhKamRj11/MnzfNFAGQ8h2ioXVw3DJnRk158eHP91B5lHyiictp7Ot4Rzd59QbK11PLNkN4u2HaW82si7o7phrZNpWXFuEjgJYUHHTpTx/+zdeVxb15338Y92AZLYxA42ZrHxjsF77MSJ3ThJ08aJs0zaadJM005nnnRz0zaedpKm0467pK2fNpm67TPNdMskbezse5w48b6A9wWDMcaAAbFJYhNCV88fF7EYbIONEMvv/XpdY662owOSvpx77vl92HUG3PbjTlobjWpQao5Fr9GRGWdh2jQr0xKtZKUZu4NSYmLX/G2vFy5cgJMVUF/fc8ddo0vejAyYMUMmewtxCVot5K2KoXraDRz681HaKispfO4Uk046WPMP8zDdn8fXnj/Iq4eraPP6+PX98zAb5PUkLk2CkxDDqNOnUHCukQ+Katl63MGpUi+drjB8LjNKRwJR4UZyEq3kzLIyM83ClHR1VCklBcLDu+5EUaCmRh1dqq1Vvw+w29UrJyWBTodSWyuVdYUYhMQ0Azc9mkfBK/E0bT/KucJ6ms5/xIp/nMtvP5fPv/y1kPdO1PDwHw/wuwfyCTfKx6MYmPxmCHGNGlo6+Oh0LR+ccrD1UCNNDj2d7jB8zVFogMkxEUzLtjIj2cbcqSbS0jSkpUFMTK/M4/dDfYMali5cUEeaAmw2utNV71W9pdimEENiNMKSe1IpzYnm1P8W4nQ0sefpA+TcPIn/eSCPL/7lIDtK6vjcf+/jD59fQGSYnFgh+pPgJMQQ+f1+Tl5w82FRLe8fc3DgRBteVxidLjN+r51wo47pCVam5VjJy7SSk6UnLU1dPqnfCW5uN1RWqoGpra1nv9ncE5Ym6Cm/QgRLxuwI7GnXsffPp/GeKuboG+WkTqvnL2un8/mXiyg418j9v9vDn76wELtF5g2KviQ4CTEIrR2d7CqpZ+upWt4raKSyUqNO7G6JACJItJnJmWJlRqqVRTMjSJ+sjioNuHRSeztUValhyens2a/Xq+kqJUU9K04OwQkRNLYoLSv/Tw6F78VR81YhFUUtWKuP8ccVKTy818GJCy7u/e1u/vyFRaREhYW6uWIUkeAkxCWcb2jlg1O1vHfUwY7DrbQ3muh0m/F3RmHQaZkab2HaVCsLplqZm2MkLU2d1K0f6FXV2akegqushLo69dAcqOEoIUENSwkJMslbiBGk1cL81bGUZ63g6F8O4669QOvr5/nNXCvfrvJR6mjhnt/s4s8PLyIzzhLq5opRQoKTEF28XRO7t56o5Z0DjRSf7VouoNUEmNSJ3ZOszEy1cn1uBJlTdKSmgtV6qTv0qpO7q6vVyd6B1bxBneCUkqKOMHXXRBFChMKkTAP2b81n1/PleA8eo77QzQ8SNPzS0EGhE+7ZtJs//dNCZqXI6vtCgpOY4BpaOthWVMs7h+r4sLAZZ50enzsMv8+CVqNhcmw40zKsLJ5uZeEsM5MmaUhIUP9SHVBbmxqUqqvV5QN6VzSKiFCL6/Y5hU4IMRqEh8PKhyZxeGoM518ppKXGyZeNGjbTyHuKjX/43R7+34PzWZwhi8tOdBKcxITi9/s5XuVi6/Fa3jrQxJGiDrxOM0q7AbARYdIzNdnKrEkWbsqzkpOtrth92ZzjdPaEJZer72VWq3r8LjFRLbIrhBi1NBrIXWYhMWMZ+/98CkP5GT6NhShnDW9ERvHgH/bx9Gfy+MSMhFA3VYSQBCcx7rV4OtlZUsfbB+t4/4CbmiotvmYzfkU9BJcUGUbOZCtLZlpYPk+d2B0Xd5m52YqijiYFDsH1PhtOo1EPwyUkqGEpImIknqIQYhglJmtZ9dUZ7HgpDt++g1yvxBNWdYH3I118+S9+fnzXbO6ZnxbqZooQkeAkxqXy+lbeO1bDm/ud7DvaRnuTCcWjByIw6rRkJ1iYPdnCqvlWcqeb+i2R1E/v+Uq1tepk7wCdDuLi1KCUkCBzloQYB8LCYNX9cRROWUH5q4dYqAF9tYNdLaV852+dNLR08M83ZIa6mSIEJDiJccHrU9hf1sBbhXW8u9dN2Tk/nc1m8GuBCGIijOSkWVk6y8JN+RayMnR9F6AcyOXmK5lMPaNKdrucDSfEOKTRQP4SI/GpC9n3wlnyNcfQVdRjPl3KLxQf9S0drL81B40sHTKhSHASY1Z9s4etJxy8saeRHYdbcdUZukaVTGg1GjJiw5k7xcLKBVYWzw4jJUVz5cGgK81XCoSlqChZZ0mICSItDaK/PIWPttiYqz+AsVyH8dBZ/tfbQX1zBz9eO1uKA08gEpzEmBGY2P1WoYO39ro4XtyJz23Cr2iAMCJMeqZNtrBkVgQ3L7Qxc6qB6Ogr3OmV5itFR/dM7pb5SkJMWBYL3PqPsexLXc7UN/ZhKtehL7jA9rYOvtTi4ZnP5kl9uwlCfspiVGvxdPLx6Tpe393AtsJmai/ou0aV1C05KozZky3cNN/CijwLk9IGMaok85WEEFdBq4XFN4VTmroM/nIQs0GH9kgNZc1H+UxLB394aCExEfKeMd5JcBKjTlldC28WOnh7r5OCEx14nMauUSUzRr2WrGQLi2ZEcOtiG7nTTcQOZlmVwHylmpq+K3eDzFcSQgxJxlQ9Md+Yz+4/2fiE/ghbT9XicB/lvtZ2nv3iUlKjZZ228UyCkwi5jk6FfaUNvLangfcPuCkvp2tdJQ1gIibCyKxJ6ojSzYusZKbrBjcQdLn5ShZL3/WVZL6SEGIIoqI1fOL/TGPPFiurDfv44HgV9W8Xcb+rnd/+6/XMSJbi3OOVBCcREg63h3cOO3hjdxN7DrfjbjTg92kAAzqNhsy4CBZMD+fmhTaWzg3DbtdcOdvIfCUhxAjS62HZvcmcSLsR/Z938uGRcgwfnOVhVzs/++oKrsuyh7qJIggkOIkRoSh+jla4eHVPPe8dcHOquBNfm6HrUiMWk54Z6RaunxfBLUtsTM80XH5dpYDAfKWaGnWT+UpCiBE2Y0kk0UkrMWzaw0d7itDtquKxprd5dN2N3JGbEurmiWEmwUkETbOnk3eON/HxC+pyAfU1+q5RJXVkKSUqjPyccD6xwMZN+RYSEgYxqgTQ2toTlGS+khBiFEhKN/GJ7y4n/LcWPnz3EBxr4OnH3+HC15fzzzdmyVpP44gEJzGsSh0tvLJHXYTy0CkPHc2BUSUDRr2WaZMiWJ4bzieXRJE73XTlUaX2dmhq6tmcTujo6Hsdma8khBgFIqxaVn4jn8iUKN796w6ocPLGDz/gQk0zj9+Xi04r703jgQQncU06OhV2FDXw6s5GPips4XwF+DsDC8EZiA4zkJ8TwaoFVlYvspGWrLt0runo6BuQmprU4HQxrVYNSDJfSQgxyuh0sOj+TGIm23jllx9QeKaG47/azb9ecLPxkesIM8oo+FgnwUkMWY2rndf21vP2Xif7jnpocQbeCLToNBoyksJZOiecWxdbyUxoJj09Hq32olV1vd6ecBQISq2t/R9Mo1FX7I6KUrfISLDZ1PAkhBCjVPbSOB5Iup2IH21l18FynM8d4fOVLTzz5E3YLaZQN09cAwlO4ooUxU9BqZOXdzbyYWEzp8/4eo0q6bCY9ORmhXNjvoXbl0aSMcmAVguKolBb2ww+X9/DbU1N0NIy8INZLGo46h2UZJ6SEGIMip8Swed/cSuRP9nOe++dxPNhMV+saeGpn68mM8Ea6uaJqyTBSQzI3e7ljX31vLnHxa7DrTTW9x7h0ZIWa2bR7HBuXWRj5XwrVmvX8TdFAVeTGo4aGjCUlann7A50fC48vH9IMhj6X08IIcaoMJuBf/jBjcROimLLH/fCiSq++fmX+PbPb2HpjPhQN09cBQlOotupymZe2tHA1gNujp324vUEwpIWk17LzClhrMiz8KmlkczKNqPV+MHthsbzcLZJDUtutxqeABQFbXOzGojM5p6AFNhkeQAhxASg1WlY/c95xKdH8ocNW6Gmiae+9Ar/8P2buHdVZqibJ4ZIgtME5un0sfVwI6/tbGLHwVaqqoHuM/u1xNmMLJwZxupFNm5dZCPG0NY1H+kM7G5S5yX5fP3v2GBQg5HNhrezE7Ky1NElIYSYwOatzuTbaVH86ttvUFnVxIv/9g5nz8zn7ntiSbGlYNYPZvE6EWoSnCaYC43tbNlZz7t73RQcb6ettecQnE6rYeokM8tzw7kjz8iCZC86dxM4q2BPU9/FJQP0+r6H26KiekKSoqDU1jK4lSyFEGL8S5sRy+P/cw+//OYbnDpaxaHf7uUvH1RQnvt7ttz3d1ZmrAx1E8UVSHAa5xTFz57TTl7e0cS2gmZKz/m6CuYCaAkzgs+8E6P5fezWffxy5XdYEJENtR1Qe9Gd6XRqSOodlCIiZN0kIYQYAqs9jEc33cqt932NlIo5zC5Owdj6Xe7q/Dw164tl5GmUk+A0DjW1enl9bwNv7XGy53A7TU29L9WQnmDiutxwVi0I4xuvT2VmeSP+TtA0wlOvfJs/3/lnjAZz32UAoqLU7yUkCSHENatur+Hj/P9muuVWphffRnX7cnQHZ/HxqXPcPGtaqJsnLkOC0zjg9/s5WdHClu0NbN3fzPFiL77OnoBjMuiYk2XipvkW7rgummnp6hoipY2lVL7dyHTAbQKnCZrMbVTlZpI+aY6slSSEEEGSbE3GZrJxatrblMbXEV4yF01rEl98ooPfPdbI6gXRoW6iuAQJTmOUp9PHuwWNvL7LyY5DrVTX9KrXhob4KANLZodxy2IbtyyKwmbpH4KSrcmYLDbeznbh04IGDVaTlcTUHAlNQggRRGa9mS33buGuv92FK3o/pvwvkXL2r9TU6nng+xX8+xc6eOSuhFA3UwxAgtMYUlHfzkvb63l3n5vCEx7a23tGlfRaLTnpRq6fF8Gnl0Yzf0b4FY+q9XnhelxYTVa23LtFjq8LIcQIWJmxkppHa6hyV5FsTaajQ8/9T55hz2EPT/yuhlNlHjZ+NQ29XqZIjCYSnEYxRfGz40QTr+1sYtvBFkrPKb2WC9BgC9ezYKaZTyywcseyaOJjhv7jvPiFK6FJCCFGjllvJiM6o+v/8NqGqXztv87y3OvN/O+7TZRWePnLE+nEREoFhdFCgtMo09ji5ZVd9by9x8Xeo+24XD2XaTSQnmRi+bxwPrkkkhXzrMPyl0jvF64QQojQ0Wo1/PqRDGakV/H93zrYe6KFVV8r4a/fn8z0dPnDdjSQ4BRifr+fo2XNvLyjkQ8KmjlR3NlnTUmzQUvuNDM3LbBw57JoMlKkOKQQQox3/3J7MtmpZh7+z/Ocq/bwyXWl/Ne3UrlliS3UTZvwJDiFQFuHj7cPNPLmbic7D7VR41D6XJ4YY2DJ3DBuXWzj1kVRhJtlorYQQkw0q3JjeHejiXufKOX8+U4+/8Ny/u2BBL56X1yomzahSXAaIedq29myvYH39rk5dNKDp6PnMr1Wy/QMIyvyIlizLJq52Vee2C2EEGL8m5ocwbb/m8NnflTM3oJOnnz2AqfOtbPx66kYjfJBEQoSnILEp/jZdsTJ67ua+PhgC2Xn+9Z0i7ToWDQrjJsXWvn0ddHERsqPQgghRH9R4QZe+4/prPvdGf7ySisvfNBIaVUHf/n+ZOxR8tkx0qTHh1G928vLOxp4Z6+LfcfacTf3rK2k0UBGipHr54XzqeuiWDbbik4nfy0IIYS4Mp1Ww//9chbTJ1XyxG/q2H+qhZVfKeHPT0xmTlZYqJs3oUhwugZ+v59DZ5p5aXsTHxY0c6rUi9JrulKYScu8HDOrFlhYsyyayYkysVsIIcTV+/JtKUxLC+MLPzxPhaODTz1ayi+/nsJdK6JC3bQJQ4LTELV6fLy+t5G3dzvZdaQNR33fid3Jdj3X5YZz6+JIbl4QSZhJJnYLIYQYPjfOjuH9X5m574lSSst8fPmn5zl5rp1/eyBR5seOgKv6VH/mmWdIT0/HbDazaNEi9u3bd9nr//3vfycnJwez2czs2bN58803r6qxoXLmQhs/e6GSW79VRObdJ/iX/6zilQ9bcNQr6HUa5k4z843PxPLRb7I4+pcZbHo0nTuWRUtoEkIIERQZCeFs+785rFhixKf4+cX/1vK5H5ylzaNc+cbimgx5xOmFF15g3bp1bNq0iUWLFrFx40ZWr15NUVER8fHx/a6/a9cu7r//fjZs2MDtt9/Oc889x5o1aygsLGTWrFnD8iSGW6fPz4eHmnhtl5PtB1spr+rsc3mUVcei2WHcssjGp6+LIsoiA3dCCCFGVoRJz4uPT+PxP53jv5538dZuNyu/WsxzT6YzKd4Q6uaNWxq/3++/8tV6LFq0iAULFvD0008DoCgKaWlpfOUrX+Gxxx7rd/377ruPlpYWXn/99e59ixcvJjc3l02bNg3qMV0uF5GRkTidTmy24Vv8S1EUamtriY+Pp6K+gzd2N/L+/mYOHG+nubXvxO6sNAPX50XwqeuiuG6mFa1WxkOvpHf/aqVo8LCT/g0u6d/gkv4dXi985OCbv6ymrd1PjE3H7x5LYXpy+7D3b7A+j8eSIQ2VdHR0UFBQwPr167v3abVaVq1axe7duwe8ze7du1m3bl2ffatXr+bll18eemuHUWNLB28dqOONnfUcKXZQdaFvfgw3a8ibodaBW7MsmtQ4mdgthBBidLrvhjhyJpn5zBPlVNf6uP/fz/ON+8P41mf6HwkS12ZIwamurg6fz0dCQkKf/QkJCZw6dWrA21RXVw94/erq6ks+jsfjwePxdH/v6irYpigKijI8x2//5406fviHuu7vNRqYnGhk4WwTty2O5BP5NoyGnpQ+XI87kSiKgt/vl74LEunf4JL+DS7p3+E3e3IE236VxWd+cJbCEx389C+tuNrP8x//lDZsjyE/r1F6Vt2GDRt48skn++13OBy0t7cPy2PMz/SRYDMwNc3H8twwbppnJskeqD7dQVNj3WVvL65MURScTid+v1+G4oNA+je4pH+DS/o3eJ79ZiTf/3Mjb+zsZOk09ZDocHG73cN2X2PVkIKT3W5Hp9NRU1PTZ39NTQ2JiYkD3iYxMXFI1wdYv359n8N7LpeLtLQ04uLihu2Yanw8FP5JobHRQVxcnLxwg0BRFDQajfRvkEj/Bpf0b3BJ/wbXpkfjKPzkBfKmJw1r/5rN5mG7r7FqSMHJaDSSn5/P1q1bWbNmDaD+8m/dupVHHnlkwNssWbKErVu38vWvf71733vvvceSJUsu+TgmkwmTqf+cIq1WO6y/AEYjaDSaYb9f0UP6N7ikf4NL+je4pH+Da1KcYdj7V35WV3Gobt26dTz44IPMnz+fhQsXsnHjRlpaWnjooYcAeOCBB0hJSWHDhg0AfO1rX+OGG27g5z//OZ/85Cd5/vnnOXDgAL/73e+G95kIIYQQQgTZkIPTfffdh8Ph4PHHH6e6uprc3Fzefvvt7gng5eXlfRLp0qVLee655/je977Hv/3bv5Gdnc3LL788atdwEkIIIYS4lCGv4xQKI7GOkww/Dj/p3+CS/g0u6d/gkv4NrmD1r6zjNErPqrtYINsFliUYLoqi4Ha7MZvN8sINAunf4JL+DS7p3+CS/g2uYPVv4HN4DIy5BM2YCE6B0x/T0oZvLQohhBBCXB23201kZGSomxESY+JQnaIoVFVVYbVa0Qxj6efAMgfnz5+fsEOOwST9G1zSv8El/Rtc0r/BFaz+9fv9uN1ukpOTJ+xI4ZgYcdJqtaSmpgbt/m02m7xwg0j6N7ikf4NL+je4pH+DKxj9O1FHmgImZlwUQgghhLgKEpyEEEIIIQZpQgcnk8nEE088MeAq5eLaSf8Gl/RvcEn/Bpf0b3BJ/wbPmJgcLoQQQggxGkzoESchhBBCiKGQ4CSEEEIIMUgSnIQQQgghBkmCkxBCCCHEIElwEkIIIYQYJAlOQgghhBCDJMFJCCGEEGKQJDgJIYQQQgySBCchhBBCiEGS4CSEEEIIMUgSnIQQQgghBkkf6gYMhqIoVFVVYbVa0Wg0oW6OEEIIMSH5/X7cbjfJyclotRNz7GVMBKeqqirS0tJC3QwhhBBCAOfPnyc1NTXUzQiJMRGcrFYroP6gbDbbsN2voig4HA7i4uImbHIOJunf4JL+DS7p3+CS/g2uYPWvy+UiLS2t+3N5IhoTwSlweM5msw17cGpvb8dms8kLNwikf4NL+je4pH+DS/o3uILdvxN52oz8tgohhBBCDJIEJyGEEEKIQZLgJIQQQggxSBKchBBCCCEGSYKTEEIIIcQgSXASQgghhBgkCU5CCCGEEIMkwUkIIYQQYpAkOAkhhBBCDJIEJyGEEEKIQZLgJIQQQggxSBKchBBCCCEGSYKTEEIIIcQgSXASQgghhBgkCU5CCCGEEIMkwUkIIYQQYpAkOAkhhBBCDJIEJyGEEEKIQZLgJIQQQggxSBKchBBCCCEGSYKTEEIIIcQgSXASQgghhBgkCU5CCCGEEIMkwUkIIYQQYpAkOAkhhBBCDJIEJyGEEEKIQZLgJIQQQggxSBKchBBCCCEGSYKTEEIIIcQgSXASQgghhBgkCU5CCCGEEIMkwUkIIYQQYpCuKjg988wzpKenYzabWbRoEfv27bvkdX//+9+zfPlyoqOjiY6OZtWqVZe9vhBCCCHEaDXk4PTCCy+wbt06nnjiCQoLC5k7dy6rV6+mtrZ2wOtv27aN+++/nw8//JDdu3eTlpbGzTffTGVl5TU3XgghhBBiJA05OP3iF7/gi1/8Ig899BAzZsxg06ZNhIeH84c//GHA6//1r3/lX//1X8nNzSUnJ4f/9//+H4qisHXr1mtuvBBCCCHESNIP5codHR0UFBSwfv367n1arZZVq1axe/fuQd1Ha2srXq+XmJiYS17H4/Hg8Xi6v3e5XAAoioKiKENp8mUpioLf7x/W+xQ9pH+DS/o3uKR/g0v6N7iC1b/y8xpicKqrq8Pn85GQkNBnf0JCAqdOnRrUfXznO98hOTmZVatWXfI6GzZs4Mknn+y33+Fw0N7ePpQmX5aiKDidTvx+P1qtzJMfbtK/wSX9G1zSv8El/Rtcwepft9s9bPc1Vg0pOF2rH//4xzz//PNs27YNs9l8yeutX7+edevWdX/vcrlIS0sjLi4Om802bO1RFAWNRkNcXJy8cINA+je4pH+DS/o3uMZr//r9fkpqm9lRUs/2kjrO1rXw4ztnsSgjdkTbEaz+vdxn90QxpOBkt9vR6XTU1NT02V9TU0NiYuJlb/vUU0/x4x//mPfff585c+Zc9romkwmTydRvv1arHfYXmEajCcr9CpX0b3BJ/waX9G9wjZf+dbg97CypY3txHTtKHNS4PH0u3/TxWZZkxY14u4LRv2P9ZzUchhScjEYj+fn5bN26lTVr1gB0T/R+5JFHLnm7n/70p/zoRz/inXfeYf78+dfUYCGEECKU2r0+9pc1sL1YDUsnL7j6XG7Sa1k4JYbctCh+/UEJO0rqqG/2EGvpPyAgxp4hH6pbt24dDz74IPPnz2fhwoVs3LiRlpYWHnroIQAeeOABUlJS2LBhAwA/+clPePzxx3nuuedIT0+nuroaAIvFgsViGcanIoQQQgw/RfFzstrFjuI6dpTUsfdsAx2dfSdJz0iysTzbzrJsOwvSYzAbdABsK3JwtNLJm8eq+dziyaFovhhmQw5O9913Hw6Hg8cff5zq6mpyc3N5++23uyeMl5eX9xnK+81vfkNHRwd33313n/t54okn+P73v39trRdCCCGCoNrZzvZiBztK6thRXEd9S0efyxNtZpZl21mebee6LDv2S4wmfXpuMkcrnbx2uEqC0zhxVZPDH3nkkUsemtu2bVuf78vKyq7mIYQQQogR0+LpZO/ZenWeUnEdxbXNfS4PN+pYnBHLsiw710+1kxlnQaPRXPF+PzkniR+9eZL9ZQ1ccLaRFBkWrKcgRsiInlUnhBBCjAY+xc/RSic7ih1sL66jsLwRr8/ffblGA3NSIlmeHceybDt5k6Ix6oc+MTo5KoyF6THsK2vgjSMXeHh5xnA+DRECEpyEEEJMCOcbWtlRUsf2Ygc7S+pxtnn7XJ4aHcbybDvLs+NYmhlLVLhxWB73U3OT2FfWwKuHqyQ4jQMSnIQQQoxLrnYvu8/Ud0/qPlvX0udyq0nPkszYrkndcaTHhg/q8NtQ3TY7ie+/doIjFU7K6lpIt0cM+2OIkSPBSQghxLjg9SkcPt/UtZ5SHYfON+FTeg6/6bQa5qVFdU/qnpsahV4X/HWJYi0mrsuy8/FpB68druIrK7OD/pgieCQ4CSGEGJP8fj9n61q6Dr/VsftMPc2ezj7XybBHdAWlOBZnxGA1G0LS1k/NSeLj0w5ePVzFIzdlBWVkS4wMCU5CCCHGjKbWDnaW1LO9a1J3ZVNbn8ujwg1cl2nvXlMpNTo8RC3ta/WsRL770jGKa5spqnGTkzh85cPEyJLgJIQQYtTydPooPNfUvabS0Uon/p6jbxh0GvInR7M8O47l2XZmJkei046+0Ryb2cCKaXG8e6KGVw9VkXOLBKexSoKTEEKIUcPv91Nc29xVzsTB3tIG2ry+PteZmmDpXiZg0ZQYwo1j46Ps07nJvHuihtePXOBbq6fJ4boxamz8tgkhhBi3rlQk124xsSwrlmXZcSzLspMYaQ5RS6/NTTnxGPVayhtaKaltJjvBGuomiasgwUkIIcSIavf62Ftax7tHKiisOs3JC+4+lweK5C7PtrMsK47pSdZxMToTbtSzNDOWbUUOtp6qleA0RklwEkIIEVS9i+RuL65jX1n/Irkzk23q2W9ZccxPj+4ukjve3JQTz7YiBx+crOXLN2SGujniKkhwEkIIMeyuXCTXRH6qhVWzUlk+Ne6SRXLHmxunxQPHKShvpKm1Y9hWJxcjR4KTEEKIa9a7SO724jpKrlAkd0psOA6Hg/j4eLTa4C9COVqkxYQzLcFKUY2bj047uCM3JdRNEkMkwUkIIcSQ9S6S+3FxHQcvKpKr1cDs1CiWZ6lrKs27qEiuoigD3e2EcGNOPEU1bj44VSvBaQyS4CSEEGJQzje0dp/5NlCR3LSYMJZlqespDWeR3PFm5fR4Nn10ho9OO+j0KSNS9kUMHwlOQgghBuRs6yqSW+JgR3EdZfWtfS63mvQs7VomYHmWXYrXDtK8tCiiwg00tXo5eL6JBekxoW6SGAIJTkIIIYC+RXK3Fzs4XOG8TJHcOOamRspoyVXQ67TcMDWOVw5VsfVkrQSnMUaCkxBCTFC9i+R+fLqOPaWjt0jueHNTTjyvHKriw1O1PHZrTqibI4ZAgpMQQkwgjS0d7DxT172m0sVFcqPDDSzNsnN9tp1l2XGkRIWFqKXj2w1T49BpNRTVuDnf0EpazOgoRiyuTIKTEEKMY4Mpkjt/cgzLsu1cnx3HzGQb2lFYJHe8iQo3kj85mn1nG/iwqJYHlqSHuklikCQ4CSHEOBIokvvxaTUoDVQkd1qClWXZ9jFXJHe8uSknnn1nG9h6UoLTWCKvFiGEGONq3e3dRXJ3ltQNWCRXrfumhqUE29gskjverMyJ58dvnWJ3aT2tHZ0SYMcI+SkJIcQY0+71se9sQ9ekbgenqi9dJHd5dhw5ieOjSO54kxVvIS0mjPMNbewsqecTMxJC3SQxCBKchBBilFMUPycuuLrrvl2uSO712XHkTx6/RXLHE41Gw43T4vnT7nNsK6qV4DRGSHASQohR6IKzTV2lu+vwW/8iueauZQLUQ3CxE6RI7njTE5wc+P1+GRkcAyQ4CSHEKBAokvvx6Tp2lAxcJHdJRmx3WMqMs8iH7DiwOCMWo15LZVMbJbXNZCdYQ90kcQUSnIQQIgQCRXK3n3awvWTgIrlzUqO6R5QuLpIrxoewrkD80WkHHxbVSnAaAyQ4CSHECBlMkdzlXXXflmbaiQyXVbonghXT4vjotINtRQ6+dH1mqJsTUhqNhpdeeok1a9ZQVlbGlClTOHjwILm5uaFuWjcJTkIIESRXLJJr1rM0Uy2Se322ncmxUiR3IrpxWjxPvnaC/WUNNHs6sZjko3k0k5+OEEIME69P4VBXkdwdxQ4OnW+iV41c9FoN8yZFsSwrjuVT7cxJkSK5AtLtEaTHhlNW38rOkjpWz0wMdZPEZcgrVgghrpLf76fU0cwfd5Xx8B8PMO8H73HPpt38amsxheVqaMqwR/Dgksn8/oH5HHz8E/z9y0v52qps8iZFS2gS3VZMiwdgW1FtiFty9f70pz8RGxuLx9N3AdY1a9bwuc99DoBXXnmFvLw8zGYzGRkZPPnkk3R2dg50dwP66KOPWLhwISaTiaSkJB577LHu27/++utERUXh86kr5R86dAiNRsNjjz3WffuHH36Yf/zHf7ym5ykjTkIIMQSBIrnbu85+G6hI7nVZXcsESJFcMUgrpsXxP7vKxvSyBPfccw9f/epXefXVV7nnnnsAqK2t5Y033uDdd99l+/btPPDAA/zqV79i+fLlnDlzhi996UsAPPHEE1e8/8rKSm677TY+//nP86c//YlTp07xxS9+EbPZzPe//32WL1+O2+3m4MGDzJ8/n48++gi73c62bdu67+Ojjz7iO9/5zjU9TwlOQghxGZ5OHwfPN7CjWC1pcqyqb5Fco05L/uRolk+1szxLiuSKq7M4IxazQcsFZztFNW5yEm2hbtKQhYWF8ZnPfIZnn322Ozj95S9/YdKkSaxYsYJPfOITPPbYYzz44IMAZGRk8B//8R98+9vfHlRw+q//+i/S0tJ4+umn0Wg05OTkUFVVxXe+8x0ef/xxIiMjyc3NZdu2bcyfP59t27bxjW98gyeffJLm5macTiclJSXccMMN1/Q8JTgJIUQvfr+f0zXNfHy6lg9OVHGo8pAUyRVBZzaoyxJ8WKSeXTcWgxPAF7/4RRYsWEBlZSUpKSn8z//8D5///OfRaDQcPnyYnTt38qMf/aj7+j6fj/b2dlpbWwkPD7/sfZ88eZIlS5b0GY277rrraG5upqKigkmTJnHDDTewbds2vvnNb7J9+3Y2bNjA3/72N3bs2EFDQwPJyclkZ2df03OUV7sQYsLrXSR3R3EdtW4pkitG3o058XxY5ODDU7V8+YaxuSzBvHnzmDt3Ln/605+4+eabOX78OG+88QYAzc3NPPnkk9x11139bmc2D89rasWKFfzhD3/g8OHDGAwGcnJyWLFiBdu2baOxsfGaR5tAgpMQYgIKFMndXuxge3FdvyK5ZoOWhekxzE00c+u8dKYn2cbknBMxtqyYGg8cp+BcI652Lzbz2FzH6+GHH2bjxo1UVlayatUq0tLSAMjLy6OoqIisrKyrut/p06ezefPmPnPAdu7cidVqJTU1FaB7ntMvf/nL7pC0YsUKfvzjH9PY2Mg3v/nNa35+EpyEEONe7yK524sd7C9rHLBI7vLsOJZn28mfHI1Rp6G2tpb4eKuEJjEiJsWGkxEXQamjhZ3Fddw6OynUTboqn/nMZ3j00Uf5/e9/z5/+9Kfu/Y8//ji33347kyZN4u6770ar1XL48GGOHTvGD3/4wyve77/+67+yceNGvvKVr/DII49QVFTEE088wbp169Bq1TNUo6OjmTNnDn/96195+umnAbj++uu599578Xq9MuIkhBCXEiiSu724jl0DFMlNijSzLMvO8qlxXJcZ269IrqL0DVZCjIQVU+MpdZzlw6LaMRucIiMjWbt2LW+88QZr1qzp3r969Wpef/11fvCDH/CTn/yk+1Daww8/PKj7TUlJ4c033+Rb3/oWc+fOJSYmhi984Qt873vf63O9G264gUOHDrFixQoAYmJimDFjBjU1NUybNu2an58EJyHEuNDi6WRPaX1XWHJwxtHS5/K+RXLjyIyLkJEkMeqsmBbHH3ae5ePTdWN2WQJQlw747Gc/i8nU9w+S1atXs3r16kvezt/rlNX09PQ+34Maivbt23fZx964cSMbN27ss+/QoUODa/ggSHASQoxJUiRXjEcLp8Rg0mupdrVzuqaZaYljq+hvY2Mj27ZtY9u2bfzXf/1XqJsTFBKchBBjxvmGVj4uVuu+7TojRXLF+GM26FiUEcvHpx18fNox5oLTvHnzaGxs5Cc/+cmwHBYbjSQ4CSFGLVe7l10lapHc7cV1nJMiuWICuGFqnBqcih188fqMUDdnSMrKykLdhKCT4CSEGDV6F8ndXuzg8CWK5C7PjmNZthTJFePTDVPt/Aew92wDbR0+woy6UDdJ9CLBSQgRMn6/n9K6lq5yJg72lDbQ7Olb8DMjLoLrs+NYlmVncWYsFpO8bYnxLTPOQnKkmSpnO3vP1ncXABajg7wDCSFGVENLBztL6rrDUpWzvc/lUiRXTHQajYbrp8bx/P7zfHy6ToLTKHNVwemZZ57hZz/7GdXV1cydO5df//rXLFy4cMDrHj9+nMcff5yCggLOnTvHL3/5S77+9a9fS5uFEGOIp9NHwbnG7nImAxXJnZ8erS4TIEVyhQDoCU7FjlA3RVxkyMHphRdeYN26dWzatIlFixaxceNGVq9eTVFREfHx/VNxa2srGRkZ3HPPPXzjG98YlkYLIUavQJHcQDmTfWcbBiySu7y7SG6szOEQ4iLXZdrRaqCktpnKpjYZeR1FhhycfvGLX/DFL36Rhx56CIBNmzbxxhtv8Ic//IHHHnus3/UXLFjAggULAAa8XAgx9jncnu4z3wYqkhtnNakFcrsOwcVLkVwhLisy3EBuWhSF5U18fNrB/QsnhbpJosuQglNHRwcFBQWsX7++e59Wq2XVqlXs3r172BsnhBid2jp87CtrYMfliuROieX6rlGlaQlS702Iobp+apwEp1FoSMGprq4On89HQkJCn/0JCQmcOnVq2Brl8XjweHr+YnW5XIBaO2o460cpioLf75eaVEEi/RtcI9m/iuLnZLVLHVEqqefAuYGL5KqjSrHMnxyNydBz+M3v9/crnTDaye9vcEn/XtnyrFg2vl/MjpI6OrydQ1p6I1j9Kz+vUXpW3YYNG3jyySf77Xc4HLS3tw9wi6ujKApOpxO/399dWVkMH+nf4Ap2/9a6O9hX7mLvORcHzrtpbOu7TECC1cDCSTYWTrIxP81KdPcq3QrOxvphb89Ik9/f4JL+vbJEox+bSYervZNtR8uYk2wZ9G2D1b9ut/vKVxrnhhSc7HY7Op2OmpqaPvtrampITEwctkatX7+edevWdX/vcrlIS0sjLi4Om802bI+jKAoajYa4uDh54QaB9G9wDXf/Nns62Xu2gR3FdewoqetXJDfCqGNxRizLsmJZlmUnY5wXyZXf3+CS/h2cZdlxvHmsmqN1PlblDn5ZgmD1r9ks8xOHFJyMRiP5+fls3bqVNWvWAOoPZ+vWrTzyyCPD1iiTydSvojKo86mG+wWm0WiCcr9CJf0bXNfSvz7Fz5GKJnU9pZI6Cs810qn0L5J7fdd6SvMmRWGYYKt0y+9vcEn/XtmKafG8eaya7cV1fPPmodV+C0b/ys/qKg7VrVu3jgcffJD58+ezcOFCNm7cSEtLS/dZdg888AApKSls2LABUCeUnzhxovv/lZWVHDp0CIvFQlZW1jA+FSHElZTXt7K95NJFcifFhHetpyRFcsea9s52qtxVJFuTMetlVGC8WD7VDsCRiiYaWzqIjjCGuEViyMHpvvvuw+Fw8Pjjj1NdXU1ubi5vv/1294Tx8vLyPom0qqqKefPmdX//1FNP8dRTT3HDDTewbdu2a38GQohLcrZ52X2mrqv2Wx3lDX2L5NrMepZmqme+LZciuWPW1tKt3PW3u3B5XNhMNrbcu4WVGStD3SwxDJIiw8iOt1Bc28zu0npum50U6iZNeFc1OfyRRx655KG5i8NQenr6mDubRoixyutTOFjepC4TUFInRXJHA0WB1lZobu7ZOjqG7e49nR5++Nc7yOloQdGAT+vie7+6g2Vf2IHJHAF6/ZW3cTxXbTxYlm2nuLaZHSV1EpxGgVF5Vp0QYnD8fj9napvZeaaeHSV1UiQ3lDo6+oajlhZwu9XQFMQ/Hhubq7E0ttDnfCtXC43H9pNoGeRJO1rt5YOVwQBmc/9N5ruMiGVZdp7dWcaO4rpQN0UgwUmIMSdQJPfj0w4+Pl1DjbvvPKVAkdzru0aVkqVUw1Vp72ynurkaW4yNcGO4uvPi0aOWlsGNIul0YLH0bMN4ZlJU5zRKD1to9jQDYFAgUh9B9Ix8QAednZfeAmvyKIra/qGOhBkMEBYGJtPAwcpsVi+TEa1rsigjFr1WQ3lDK+X1rUyKDQ91kyY0CU5CjHJXLpKrYX56jBTJHUYfnHqbLzx3H7NIx+E+y69u2MDCyBlqULrc6FFYWN+AFISgdDEz8KsvvdxnjtNv792CKSPvyjdWlP5hyucDr7fv9x0d0N7ed1MU9Xpe7+UfQ6NRw9PF4cpoRNPSArGxMnJ1BRaTnnmTothf1sjOM3VMipVVxENJgpMQo4zf76eoxq0uE3CJIrk5iVauy4plll3PzbkZRJjl7Lchu8ToUYezgd++cB9zvR4ywtvQtbbw85e+xZ/v/DNGnbH/6FFgi4hQLwuBlRkrqXm0Zuhn1Wm1YDSq21B5vf3D1MWbx6MGzcD3TmfP7RUFo9MJpaVqeLLb1S0qSoLUAK7LsrO/rJEdxXVSfiXEJDgJMQrUutrZUVLXvfjkQEVyl2epZ78ty1KL5CqKQm1tLWHG0HxYjxm95x71PrR2idGjhuZqWr1tePQamiL0lBr9uIxtVM2cRHra7KCOHl0Ls95MRnTGyD2gwaBuVuulr+P3Dzxa1d4Ora34AyNX9fXqVlSkhs+YGDVExcaqQUoO9bE8287G94vZeaYORfHLqHIISXASIgQCRXK3n3awo0SK5F6z4Zp7FBFBVJiBHWe/idvbSp7NwgmXlghTBIlTZoOsjzQ0vQ/TRUb2vUxR6JgyRR2pa2iAujp16+gAh0PdQJ2c3ntEymqdkEFqTmoUFpOeplYvx6tczE6NvPKNRFBIcBJiBCiKnxMXAkVyHew/20iHr6dYpkajFsldnh3H8iw7eZOjMRtkJGlAigIuFzQ19WzNzUObexQR0TP36KIPYTPw4j+8xN1/uxsAq8nKi/e+KItKBktEhBqGJk9Wv3e7e0JUfb16SLCmRt1AHeUKhCi7Xf05TgAGnZbFGTG8f7KWHSV1EpxCSIKTEEFS1dTWXc5kZ0kdDS19Rz6SI81dC0/GcV2WnRhZEbg/v1/9IO0dktzunrPBehtg9Air9armHq3MWEnlukpOl59m6qSpPWfVieCzWtVtyhT15+9y9QSphgY1SF24oG6gjmYFQlRsrPrzHqeWZdl5/2QtO0vq+JcVmaFuzoQlwUmIYdLs6WRP13pK24sdAxbJXZKpFshdlh1H5jgvkjtkfr96iK13SHI6Bw5JRqM69yUysufrAKNH18KsN5NoSZSRplDSaNSfbWQkZGaqvwtOZ98g5fFAZaW6gTq6GBcHyclqmBpHr7Fl2Wr5lX1lDbR7fTIqHSISnIS4Sp0+hSOVTnVCd3EdheX9i+TOTVNX6V6ebSc3beIVyb2s1tb+Iamzs//19Ho1HPUOSuEyAjQhabUQHa1u2dlqkGps7AlSTU3Q1gbl5epmNqsBKjW1/xyrMSgzzkKizUy1q50DZY3dQUqMLAlOQgxBeX0rHxcHiuTW4Wrv+0E/OTacZVlq3bclmXYiw2SZAEA9i6p3SGpqGnj9H52uJxwFglJExLgaNRDDSKtVD8/FxsK0aeqaUw0NUF2tjkC1t6vLHZSWqof/UlLUEBU2NheF1Wg0XJdlZ3NhBTtK6iQ4hYgEJyEuY7BFcpdPVReflBV9Uc+Kungkqb29//W0WrDZ+galCXrGlBgmOp16mC4uDmbOhNpaNUBVV6tz406dUrfYWDVAJSWpk83HkGXZsV3ByQHkhLo5E5IEJyF66V0k9+PiOo5U9C+SmzcpWl1PSYrkqqNGTmffoNTW1v96Go0ainqHJJttWBY67L34dWAh68D/fb7Bb4EKJIGvXi80NZm6s5zfr+73+/v+/+KvgS3wtAfqioH+H6DVDn3T6XrKyg30/977Altg3UuDIWTrdgaXVguJieoWmFBeWdlztl59PRw9CgkJaoiKjx8TC29el6WOMh2vctHQ0iEnlYSABCcxofn9fs44WthR7GB7cR17Sutp6ei7SndmXATLpUiumi4uDkktLQNf12Lpf8it16ezzwcdnp7yaL03T6/9A4Wh3v8PVAQJBkUBt1tLW9uY+Dy9JoEFxA2Ggb8GlmLqXTWl9/ejvn8MBpg0Sd3a2nomk7tcPWfoGQzqfKiUFHUBzlE68hlvNTMtwUpRjZvdZ+r55JykUDdpwpmgnwBiImto6ehapVsNSxecfQ8jxUQYuS7LzvIsO9dl20mZiEVyL14ryelUD3X0WispMErj0YXjCY/CY4qkzRRFiz4Sj2LA0wye+r5BKLANdKLctdJo1M8+vb7na2C05Wo2gMbGDux29X40GnXTagf+evH/A3ovLzXQUlMXXx4YvRrKFgiQvcvLXe7/gQAamGamKD0Lel8Ng6FvqAoPV6cRDfTVZLq6xxg2YWGQlaVuLpcaoCoq1Cd/7py6hYWpo1ApKZdfGT1ElmXb1bJMJXUSnEJAgpMY9zydPgrKGtnetUzA8SrXRUVytSyYEs2yLPXstxlJE69Irr/TR3tVA56qejqr6+hwOPF6FDwd0OlVw47XC+2YaTFE0ayPotUQSUd4FIr+6g8VBA4XXWoLVPUIhKGB/h/4frgPNykK1Nb6xsoRnKvi96s/18DPN/D/i7/3eHpKzwW+BrbAfXi96jqkV6LV9gQor9dIaqp61Lb3uqTh4SM04GOzqVtOjnrorrISqqrUUaniYnWLjFRDVHLyqCm3syQjlv/ecZY9pfWhbsqEJMFJjDsXF8nde7aedm/fIY6cRCvLs9X1lBamx4zLem+dneoZ/21t6tbe3vP/thaFTkcjiqMO6uqhqRHNRcNAit6IJzyKjrBIOsKi6IiJwmfo+8Gh0YC51yGbgb5eLhSN0qMhE4ZGc/U1fqGnFF3vQBX4HQv87rW29vzf41EDaXOzOtjjdutoauofTAPhKrCWqdXacx6BzRaE1Sg0mp5FNGfNUlcpr6xUvzqd6nbihHp5RoY6HyqEFmbEoNXA2boWqp3tJEaOjkA3UUhwEuNCrbu9ez2lgYrkxltN6jIBU+1cl2Un3jp232g6O3tKsZ0/r6Ompu8HVGDrU6LN78fY2oS5uQ5zSz2mlgY0io/eucVnDEOJsaOJs6O1x2CMCicy7MqhSMLPxNW7FJ3NduXr+3w9v6vq768Xk6l/mcFAuLrUCJZe3zdIBb4OyxJfOp06upScrL6IqqrUENXQ0FNDz2ZTF+RMTg7JcKTNbGB2SiSHK5zsLq3jznmpI96GiUyCkxiTBlMkd3FGbNeaSnFMTbCM+lW6/X71QyUQigJfe4ehlpa+81LcbiNW6wDv3X4/hnYXlrY6bN56rB31mPWd6uhCHBhTwGAxYUiyY0y2Y0yKxRwbMW4PSYnRoXdVHLsdwsM7+x0KVRT1dRAITs3N6vQ6l0sd+GluVv94aGhQt4uZTOr6mDExPWtlRkdf5dJNRiOkp6tbSwuUlakLa7pccPCgurRBRoY66Vw/sh+nizNjOVzhZFdJvQSnESbBSYwJgymSOys5sqv2m538ydGY9KPr8JvH0zcQ9f4Lu/df2oOh1wcm4SokJXV9GPndWD11RLTVEdZaj0nr7btETaA4aqDS/Cic9CqEVqvOdYqIUFcKuJj6B4MaolyunkAVOH/B41GXbaqu7ns7s1kNUIFf/7g4daRq0H8sRESoa0NNnaoGqLNn1YR3/DicPq2GqylTRmz2+5KMWH77USm7ZZ7TiJPgJEatQJHcj4sd7DpT369IbkpUWFfdN3vIi+T6/eqIkNvdd+sdjAaqJjKQwNyOwETZiAh1X+/NqFdQ3G7qTpdg12jQBmp2BZhQ01XgUyI2Vj28MMpH3YS4Eq22p3zdxTo71QDV2KiORjU2qpvLpc7B6l0bGNSXSEyMGqICYSo6+govE4NBLfeSmQnnz8OZM+qLvLhY/X9amnpZkIsNL0iPQa/VUNHYxvmGVtJiZPHdkSLBSYwagSK524sdbC+po3TAIrn2rknddjLsI1skNzAPw+Ua+OtgRovM5p5DFb2DUWBfePhFfwEHhqmam6GxGc53JbHWVvD5MDidPX8263Tqp0AgLEVFSVASE0rgb4XY2L77OzvVVTUaGtST5xwO9avXqy4uXlvbc12DQR3pCmzx8ZeYPK/VwuTJ6mG66mooKVEf5Nw59XBeUpIaoKKigvJcI0x65qRGUljexO7SeglOI0iCkwiZ3kVytxc7OFjeNHCR3Cw7y6fGBb1Ibmdnz9B/YOs9enSlhRa12p4zgKzWnjDUOygNeMq8oqhhyN0MFy46hjdQPbcAvR4lOlpdjyY+Xv1TWSYpCdGPXt9z0lyA36+OTgXqA9fVqYHK61WXdaqo6LluTIy6AHlgznifVQk0GjUkJSWpaaykRE1iVVXqZrerASoIZ+ItzbRTWN7EnjP13Ds/bdjvXwxMgpMYUefqW9R5SsV17DxTh3uEi+R6vT1zInrPj3C5Lr0IdoBGo4afQDC6eLtiLVqPB5qa+09wam0deGXEgN7nZffeDAa8tbVjplSEEKOJRtOzsH1WlrrP71dHpWpqejaXq2ci+okT6vViY9W1MVNS1EDVPZcwMNzlcqmH7QIlXurq1EPlWVlqwBqm1+uSzFie/rCE3aX1+P3+UX8CzHghwUkElbu9k8Jj1ew4U8+OSxTJva5rntJwFcnt6OgbiHp/HaiMWm9GY8/8iYuDkcUyyPc7v18NRIEVt5ua1CGrK4weDRiOIiIu/aDBWH5biAlMo+nJPjNmqPtaW9UAFSh119jYU+ruyBH15ZmUpB6xmzy5a1kGmw3mzVMX1iwtVQ/fuVxQWKie3tfrTLz2znaq3FUkW5Mx64e2TEr+5GiMOi0XnO2U1bcyxR7ceVVCJcFJDKu+RXIdHKlw9i+SOzma5V1haU5qFLqrWKXb71cHbHpnk8DW2nr525rNPWu/BNZ/CXx/VSfEtLb2LU3S1HTpmeCXGj0KeR0KIcRAwsPVk+WmTFG/b23tOQpXWan+TRQofbd7tzqCNXmyuiUkhKG5zJl4u3UX+PTer1Hnc2Mz2dhy7xZWZqwcdNvMBh25k6LYd7aB3WfqJTiNEAlO4poMpUju8mw7izKGViTX6+0fjAL55HJzjsLC+i+OF/h6taskA+qpORc3pKOj//V0up4it4EHHvSQlRBitAoP7yl1B+pbQHm5OqhUXd3z1nD4sHrdzEzIzDQQf9GZeB2uRja+9H9Y1NnGuUg4G+3irr/dRc2jNUMaeVqSEasGp9J6PrNoUlCes+hLgpMYsvpmDzvP1F+xSO6yrFhyomB2ZiraKwQGj6fvKcSBN5/LzTsKnJYcmKfQ+//XFI4COjr6D2kNVAVVq1WP5QUePCpK/V7mGwgx7kVGwuzZ6tbRoeaiwIl1ra1w9Ki6Wa2QmaklO3sy0TdO4sKpvVTp2ojyQnoTNBuhzOiiyl1FRnTGoB9/aWYs/3drMbvPyDynkSLBSVxRu9dHwblGthf3FMnt7VJFchVFobb3eb6obyyBtVV6r7NyucNrZnPfTBLYhnUAJ7BUcWAlvUsd89No1HfA3inNZpORJCEERmNghEkdEa+oUOeIl5Wph/QOHVK3hAQNGdnzOJwZjdHVyOQmOB8JNpONZGvykB4zd1IUJr2WumYPZxzNZMXLwrbBJsFJ9OP3+zlV3VUkt6SOfVdRJNfrDZyZq6O0VM0iDQ2XH0GyWPqWSAjkkmGb/uPz9V+uO7Bd6rhfRETftBYZeYk1BYQQoodO1zPXqbNTHYEqKVFHo9Qz9kx82bCDZ5zfoDB6L7YwP1vu3TLkCeImvY756dHsLKln95l6CU4jQIKTAKDW1d5VzkTdHBcVyY2zmrrWU+pbJNfvV/+SqqnqOdOkoUE9geRStdTCw/vWkYqJGcbDa9C30FXvgHS5U+p6rzXQOyQZhnc5BCHExKPXqyfSZWSoA9lFRWqZuyxm8NO5r9PU3sTsqZHMCLu6N8ElGbHsLKln15l6PrckfXgbL/qR4DRBtXX42Hu2vmvxyTqKavoXyV00JZbl2T1Fcn0+jbrybgWc7hWSLnWWfVgYWCwK6enq6b2BoDQsI0g+X9eike7Bjx6Bms4uPt3falUbK4fbhBBBFh6urlSQm6uemXf8uIGysjiqK+G1SrXsS25uz1l8g7EkU10qfU9pPYriR3sVZyqLwZPgNEEoip/jVS62lzjYfrqOgnP9i+TOTonsrv02LTaaZqeO+nooPwoHt6mjSAPRatVRo0C1j9hY9f9GI9TWeq5tfcbA6NHF4Wgwo0cX1zaxWIZxWEsIIa6eRtOziKbTqU4gLypSVy9/7z11wfEFC9TSd1cyJzWKMIOOxlYvZxzNZCfI4bpgkuA0jlU2tXWf+bazpI7G1r5DQylRYSzPtpOXHEeWNZbOViN1dVCyE44NcPIY9BxmCwSk2NhLVxgf9PqMwzl6NGDBNyGEGL0iI2HZMpg/H44dU0NUXR289Za6uOaSJX3LxVzMoNMyb1IUu87Us/dsgwSnIJPgNI5cuUiunvykeGbHxpFpi8HgDaO+XkPTUThw0X1pteo0n94BKSZGPaJ11drbBw5HMnokhBCYzWp4mjVLPfvu+HF1xfItW9SVzBcsuPRUh4VTYth1pp79ZQ384+LJI9ruiUaC0xjW6VM4XKEWyd1R0rdIrt8PdOiZFmknJzqO9IhoIrUR+Dq10AR1TT33EzjUZrerx9ftdvX7IZ085verizF5PGpAam+H1lb058+rAae1dfCjR73DkYweCSEmGLMZFi9W14bau1c9G+/ECbV6y7Jl6iTziy1MjwFgb2kD/svVvhTXTILTGBMokru92MGuM/XdRXIVrxal1Uyc3ka2zU6qOZrJ0RGEGbt+xAr4FDUMxcb2VAq32yHc1k51y2VqJXm9PWHoUpvH079QraKgczp7juXJ6JEQQgxaRATcdJNa8m7nTnXNu/ffh+xsuO66vm+b8yZFo9dqqHa1U9HYRkrU0JY1EIMnwWmUc7Z62XVGXU8pUCTX79PgazOitIZh8oaTYYllSpSNrFQLMRE947h6fU9ICowkRUX1HcD54PS7/NP/XYu3tZk4rYVNKzeyOC63byga7GQljUYdRzab1c1goLOtrafypYweCSHEkCUnw9q1UFCgHsIrLlYP4d18c8/cpzCjjjmpkRSWN7HvbAN3zhvaQppi8CQ4jTIdnQoHyxvZUaIuE3D4fBOdbQaUViO+VjO0RZIaHklWnIXsqVZSosLQajVoNOqp/vHx6hYXp35/uZzS3tnOP/3lbuacacYPaGjml//7Ff58558x6i4aATIaewKR2dw3IPXe13u5f0XBV1vLtZ1WJ4QQQqtV5zhNngwffKCe5fzqq3D99T118xZMiZHgNAIkOIVYoEju9mIHO4rr2HW6AXeTHl+LCV+LCaU1lbiIMLLiLWSlWphij8Bs0BER0ROS4uPVvzqGulZjlbuKWp8btxHa9eDRQZuhjerJsUxKmNo3FEnwEUKIkIuPh7vuUsNTebn6tblZXftp0ZQYfvtRKfvLGkLdzHFNglMIBIrkbj/tYNuxRqou0BWUjCjtSUSY9EyNs5A11UJ2ggW7zUhcXN+gFB5+7e1ItiZjsNr4aIobP340aLCarMTPXgxDXPZfCCHEyDAaYfVq2L9fPXS3b586FTV/VgwaDZTWtfSr/iCGjwSnEeDp9FFQ1si2U3V8cLiJE2c6ukeU/J0x6LVa0u3hZGVayIq3kDMpjKQkDYmJkJCgzksKRsFrs97Mlnu3cNff7sLlcWE1Wa+qVpIQQoiRpdHAwoXqDIm9e+HgQdDpDOQk2jh5wcX+sgbmJ0hdzWCQ4BQEgSK5207U8X6hiwMnW2lzGvG1GsEfDoSTaDOTPcXCtEQr83PCmZSqIyEBEhPVI2MjZWXGSmoeraHKfZmz6oQQQoxKc+eqZ0vv2gUHDkCWKYGTuNhf1sj8hMusmimumgSnYVLraueD43W8e8DF7mMt1Ndq8bUZAC1gwWo2kJVmYVZaBEtnW8jJMJKQoM5NGtJ6SUFg1pvJiB5gYRAhhBCj3qxZ6jynI0dAWx2Pr62MfWUN/MsiCU7BIMHpKrV1+PjoRD3vHHCy83ALZ8/7UNoDs7NNGHVashIimD0lnOtzrcyfrh5+s9lC2mwhhBDj0KJF0NQErvYI2g/HctJcjbu9k/hQN2wckuA0SIri58AZF2/ubWL7oWZOnOmgoy0wVKRFo9GSGh3G7IxwrpsTwQ25VtLTdMMyiVsIIYS4HI1GXZqgttZAjM6Cu9bGkQstZE4KdcvGn6sKTs888ww/+9nPqK6uZu7cufz6179m4cKFl7z+3//+d/793/+dsrIysrOz+clPfsJtt9121Y0eKaU1rbyxu5EPDzZTeLIdt6v3DG0dUeFG5mSaWTo7gk/kR5KTaRzR+UlCCCFEQHi4WhA4fWcEBRU29p9t5s5FoW7V+DPk4PTCCy+wbt06Nm3axKJFi9i4cSOrV6+mqKiI+Pj+g4K7du3i/vvvZ8OGDdx+++0899xzrFmzhsLCQmbNmjUsT2K4NDR7eWd/E+8fcLHveBtV1b1XzNZg0uuYkWHqCko2FswIx2wOwuluQgghxFXIyoLZmWEcOKdhV6Ef/iHULRp/NP4hVgNctGgRCxYs4OmnnwZAURTS0tL4yle+wmOPPdbv+vfddx8tLS28/vrr3fsWL15Mbm4umzZtGtRjulwuIiMjcTqd2IZxklB5XQuvbq/gUKmWwlMeyisV/L2ykkYDGckmFs4K4xPzbazMt2EJl4UgB0tRFGpra4mPj0crC2gOO+nf4JL+DS7p3+DZfqCNNd8rRm/yceb5WVjChrg68mUE6/N4LBnSiFNHRwcFBQWsX7++e59Wq2XVqlXs3r17wNvs3r2bdevW9dm3evVqXn755Us+jsfjwePpWbzL5XIB6gtNGWzdtCt4+tUL/OD3dfh9fUeM4qL15E83s2JeBLctiiLJ3vcXbrgefyJQFAW/3y99FiTSv8El/Rtc0r/Bs2iOkUiLDmczvF/QxKeXxg7bfcvPa4jBqa6uDp/PR0JCQp/9CQkJnDp1asDbVFdXD3j96urqSz7Ohg0bePLJJ/vtdzgctLe3D6XJl5Qe5UWjaEiI1DEzU8f8HAPLZpvISAp0iR+URmprh+XhJiRFUXA6nfj9fvmLMgikf4NL+je4pH+Da3qGnz1HYOehehZn+Ybtft1u97Dd11g1Ks+qW79+fZ9RKpfLRVpaGnFxccM2NHhLjJ89v/ESZmwkPj5OXrhBoCgKGo2GuDjp32CQ/g0u6d/gkv4Nrv/853A8LU7yZiQNa/+a5QyooQUnu92OTqejpqamz/6amhoSExMHvE1iYuKQrg9gMpkwmUz99mu12mH7BTAaYcokDbW1mmG9X9GXRiP9G0zSv8El/Rtc0r/BM3uKhdra1mHvX/lZqctaD5rRaCQ/P5+tW7d271MUha1bt7JkyZIBb7NkyZI+1wd47733Lnl9IYQQQojRasiH6tatW8eDDz7I/PnzWbhwIRs3bqSlpYWHHnoIgAceeICUlBQ2bNgAwNe+9jVuuOEGfv7zn/PJT36S559/ngMHDvC73/1ueJ+JEEIIIUSQDTk43XfffTgcDh5//HGqq6vJzc3l7bff7p4AXl5e3mcob+nSpTz33HN873vf49/+7d/Izs7m5ZdfHnVrOAkhhBBCXMmQ13EKBafTSVRUFOfPnx/WdSMURcHhcMjkxCCR/g0u6d/gkv4NLunf4ApW/wZO1mpqaiIyMnLY7ncsGZVn1V0scPpjWlpaiFsihBBCCLfbPWGD05gYcVIUhaqqKqxWKxrN8JU4CSTn4R7JEirp3+CS/g0u6d/gkv4NrmD1r9/vx+12k5ycPGFHCsfEiJNWqyU1NTVo92+z2eSFG0TSv8El/Rtc0r/BJf0bXMHo34k60hQwMeOiEEIIIcRVkOAkhBBCCDFIEzo4mUwmnnjiiQFXKRfXTvo3uKR/g0v6N7ikf4NL+jd4xsTkcCGEEEKI0WBCjzgJIYQQQgyFBCchhBBCiEGS4CSEEEIIMUgSnIQQQgghBkmCkxBCCCHEIElwEkIIIYQYJAlOQgghhBCDJMFJCCGEEGKQJDgJIYQQQgySBCchhBBCiEGS4CSEEEIIMUgSnIQQQgghBkkf6gYMhqIoVFVVYbVa0Wg0oW6OEEIIMSH5/X7cbjfJyclotRNz7GVMBKeqqirS0tJC3QwhhBBCAOfPnyc1NTXUzQiJMRGcrFYroP6gbDbbsN2voig4HA7i4uImbHIOJunf4JL+DS7p3+CS/g2uYPWvy+UiLS2t+3N5IhoTwSlweM5msw17cGpvb8dms8kLNwikf4NL+je4pH+DS/o3uILdvxN52oz8tgohhBBCDJIEJyGEEEKIQZLgJIQQQggxSBKchBBCCCEGSYKTEEIIIcQgjYmz6oQQQohrdcbRzOaCCl49XEV0uJG/f3kJZoMu1M0SY4wEJyGEEONWU2sHrx25wOaCCg6db+reX9HYxmuHq7hnviyuLIZGgpMQQohxpdOn8NFpB5sLK3j/RC0dPgUAnVbDDVPjsJr1vHKoir/sLZfgJIZMgpMQQohx4eQFF5sLKnj5UBV1zZ7u/TmJVu7OT+XTucnEW83UNXt462g1h883caSiiTmpUaFrtBhzJDgJIYQYs+qaPbxyqIrNBRWcuODq3h8bYeSO3BTW5qcwMzmyz23sFhO3zk5UR532nOOnd0eNcKvFWCbBSQghxJji6fSx9WQtWwor2FbkoFPxA2DUaVk5PZ61eancMC0Og+7SJ45/bvFkXjlUxauHq/jubTOIDDeMVPPFGCfBSQghxKjn9/s5dL6JzYUVvHb4As42b/dlc9OiuDsvhU/NTSYq3Dio+8ufHE1OopVT1W5eLKzgC8umBKvpYpyR4CSEEGLUuuBsY0thJVsKKzjjaOnen2gzc2deCmvzUsiKtw75fjUaDZ9bMpnvvnSMv+w5x0NL09FqJ27hWjF4EpyEEEKMKm0dPt45Xs3mwgp2lNThV4/EYTZouWVmImvzU1maaUd3jUFnTW4KG948xdm6FnadqWdZtn0YWi/GOwlOQgghQk5R/Owra2BzQQVvHr1AS4ev+7KFU2K4Oy+VW2cnYjUP31ykCJOeu/JS+NPuc/x5T5kEJzEoEpyEEEKEzLn6Fl46dIEthRVUNLZ170+LCeOueamszUtlUmx40B7/HxdP5k+7z/H+yVouONtIigwL2mOJ8UGCkxBCiBHlbvfy+pEqnt9TxuGq5u79FpOe22YnsjYvlQXpMSMy52hqgpVFU2LYe7aBvx+o4Ksrs4P+mGJsk+AkhBAi6HyKn50ldWwurOCd49W0e9XVvDUaWJZlZ21eKqtnJhJmHPnacXfnp7L3bANvHr0gwUlckQQnIYQQQVNS6+bFgkpePlhJtau9e39mXASrp0bx2WXZpERHhLCF8IkZCei1Gk5Vuyl1NJMRZwlpe8ToJsFJCCHEsGps6eC1I+pq3ocrnN37I8MMfHpuMmvzU5mdbMXhcBA/CuYURYUbWZpl5+PTDt46Vs3/uTEr1E0So5gEJyGEENfM61PYVuRgc0EFW0/V4PWpawjotRpWTItjbV4qN02Px6RXD8UpihLK5vZz26zEruB0QYKTuCwJTkIIIa6K3+/neJWLzYUVvHqoivqWju7LZiTZWJufyh25ydgtphC2cnBunpnId18+xrFKF+X1rUE9k0+MbRKchBBCDEmtu51XDlaxubCCU9Xu7v12i4k756mH4nISbSFs4dDFRBhZnBHDzpJ63jx2gS/fkBnqJolRSoKTEEKIK2r3+nj/ZA1bCiv56LQDX6/Cup+YkcDa/BSuz45Df5nCuqPdrbOS2FlSz1tHJTiJS5PgJIQQYkB+v5/CcrWw7uuHq3C1d3ZfNm9SFGvzUvnUnGQiw4dvNe9QWj0zkX9/5RiHK5xUNLaSGi2H60R/EpyEEEL0UdnUxkuFFWwprKS0rqewbnKkWlj3rrxUMsfhKftxVhML09XFMN8+Vs3DyzNC3SQxCklwEkIIQYunk7ePqYV1d5fWdxfWDTPouHWWWlh3SUbsiKzmHUq3zU7qXgxTgpMYiAQnIYSYoBTFz56z9WwuqOStYxdo7VVYd3FGDGvzUrl1dhIW08T5qLhlViJPvHqcwvImqV0nBjRxXg1CCCEAKKtrYXPXobjKpp7CupNjw1mbl8qd81JIi5mY83sSbGbmT47mwLlG3j5WzUPXTQl1k8QoI8FJCCEmAGeblzeOXGBzYQUF5xq791tNem6fm8TavFTyJ0ej0YzvQ3GDcevsJA6ca+TNoxckOIl+JDgJIcQ45VP8bC92sLmwknePV+PpVFfr1mpgeXYca/NTuXlGAmbDyBfWHc1unZXIf7x+ggPnGuVwnejnqhbceOaZZ0hPT8dsNrNo0SL27dt3yev+/ve/Z/ny5URHRxMdHc2qVasue30hhBDX5nSNmw1vnmTJhq18/tn9vHa4Ck+nwtQEC+tvzWH3+pX88Z8W8um5yRKaBpAcFcb8ydH4/fDGkQuhbo4YZYY84vTCCy+wbt06Nm3axKJFi9i4cSOrV6+mqKiI+Pj4ftfftm0b999/P0uXLsVsNvOTn/yEm2++mePHj5OSkjIsT0IIISa6hpYOXj1UyebCSo5W9hTWjQ43cEduCmvzUpmVYpNDcYP0qbnJHDjXyOtH5Ow60ZfG7w+cdDo4ixYtYsGCBTz99NOAWqgxLS2Nr3zlKzz22GNXvL3P5yM6Opqnn36aBx54YFCP6XK5iIyMxOl0YrMN3zL+iqJQW1tLfHw8Wu3YXe12tJL+DS7p3+AaC/3b0anwYVEtLxZU8OGpWjqVnsK6N+XEszY/lRunxWPUj772j/b+rXW3s/g/t6L4Yfu3bxxzk+WD1b/B+jweS4Y04tTR0UFBQQHr16/v3qfValm1ahW7d+8e1H20trbi9XqJiYm55HU8Hg8ej6f7e5fLBai/CMNZUVtRFPx+/6ir0j1eSP8Gl/RvcI3W/vX7/RyrcrGlsJJXD1fR2OrtvmxWio2181L41NxkYiKM3ftH23OA0du/AfYII4szYtl1pp5XD1fyL2OsBEuw+ne0/rxG0pCCU11dHT6fj4SEhD77ExISOHXq1KDu4zvf+Q7JycmsWrXqktfZsGEDTz75ZL/9DoeD9vb2oTT5shRFwel04vf7R+VfPGOd9G9wSf8G12jrX0dzB2+fauCtk/WU1ve8D9ojDKzOieGTM2LJiFUnMXe2NFHbcql7Gh1GW/8O5Pr0CHadqeflgvOsnW4NdXOGJFj963a7r3ylcW5Ez6r78Y9/zPPPP8+2bdswm82XvN769etZt25d9/cul4u0tDTi4uKG/VCdRqMhLi5u1L5wxzLp3+CS/g2u0dC/7V4f755QC+vuKKmj60gcJr1aWPeueSksy4odk4V1R0P/Xsk9S6J46sPzFNe14SaczPixU2YmWP17uc/uiWJIwclut6PT6aipqemzv6amhsTExMve9qmnnuLHP/4x77//PnPmzLnsdU0mEyaTqd9+rVY77C8wjUYTlPsVKunf4JL+Da5Q9K/f76fgXGNXYd0LuD09hXXnT45mbX4qt81OIjJs7BfWHe2/v7EWM8uz7XxY5OCNY9V8fdXUUDdpSILRv6P1ZzWShhScjEYj+fn5bN26lTVr1gBqqt26dSuPPPLIJW/305/+lB/96Ee88847zJ8//5oaLIQQ49H5hlZeOljJlsIKyupbu/enRIWxtquwbro9IoQtnJg+NTeZD4scvHa4iq+tzJazEsXQD9WtW7eOBx98kPnz57Nw4UI2btxIS0sLDz30EAAPPPAAKSkpbNiwAYCf/OQnPP744zz33HOkp6dTXV0NgMViwWIZO8OeQggx3Jo9nbx1VF3Ne09pQ/f+cKOOW2clcXd+KoumxIz7wrqj2SdmJGDUaznjaOFUtZvpSRPzTDLRY8jB6b777sPhcPD4449TXV1Nbm4ub7/9dveE8fLy8j5Deb/5zW/o6Ojg7rvv7nM/TzzxBN///vevrfVCCDHG+BQ/u8/Us6WwgreOVdPmVQvrajSwJCOWtXmp3DIrkYgJVFh3NLOaDdw4LY53jtfw2uEqCU7i6iaHP/LII5c8NLdt27Y+35eVlV3NQwghxLhS6mhmc2EFLxVWUuXsOStuij2CtXkp3JmXSkqUlPYYjT41N1kNTkeq+NbqaXK4boKTP2mEECJInK1eXjtSxebCCg6WN3Xvt5n13D43mbV5qeRNipIP4lHuppx4wo06zje0cbjCSW5aVKibJEJIgpMQQgyjTp/Cx8UONhdU8t7JGjq6CuvqtBquz7Zzd34aK6fHS424MSTcqGfV9ARePVzFywcrJThNcBKchBBiGJy84GJzQQUvH6qirrmn8kFOopW1eancMS+ZeKusgTNW3TkvhVcPV/H6kSq+98npY3LtLDE8JDgJIcRVqmv28MqhKjYXVHDigqt7f2yEkU/nqofiZiZLYd3xYFm2nZgII3XNHewoqWPFtP5F7cXEIMFJCCGGwNPp44OTtWwurGBbkaO7sK5Bp2FlTgJr81NZMS0Og4xIjCsGnZbb5yTxp93neOVQlQSnCUyCkxBCXIHf7+dwhZPNBRW8dqSKpl6FdeemRrI2P5VPzUkmuldhXTH+rJmXwp92n+Od49W0dnQSbpSP0IlIfupCCHEJte4ONp88w0sHqyipbe7en2Azcee8VO7OTyErfmwVfxVXb15aFJNjwzlX38p7J2q4Izcl1E0SISDBSQghemnr8PHO8WpeLDjPzpJ6uurqYjZoWT0zkbV5qVyXZUcnq3lPOBqNhjtyU/jV1mJePlgpwWmCkuAkhJjw/H4/+842sLmwgjePVtPcq7DugvRo7u4qrGs1j/3CuuLarMlN5ldbi/m4uI66Zg92S/+C9GJ8k+AkhJiwyutb2VxYwZaDFZxvaOvenxYTxp25Kdww2cy87DSpCC+6ZcRZmJsayeEKJ28cucCDS9ND3SQxwiQ4CSEmFHe7l7eOVvNiYQX7zvYU1rWY9Nw2Wz0UtyA9BvBTW1sbuoaKUeuO3BQOVzh56WClBKcJSIKTEGLc8yl+dpbUsbmwgneOV9PuVVfz1mhgWZadtXmprJ6ZSJixZzVvRfFf6u7EBHf73CR++MYJDp1voqyuhXR7RKibJEaQBCchxLhVUuvmxYJKXj5YSbWrp7BuRlwEa/NSuXNeCslSWFcMUbzVzLLsOD4+7eDlQ5V8fdXUUDdJjCAJTkKIcaWptYPXDlfxYmElh883de+PDDPw6bnJrM1PZW5qpKzmLa7JnfOS+fi0g5cOVvK1ldny+zSBSHASQox5Xp/CR0UONhdWsPVkLR2+nsK6N06LY21eKjdNj8ekl8K6YnisnplIhPEY5+pbOXCusWtenJgIJDgJIcas41VONhdU8urhSuqaO7r3T0+ycXd+KnfkJsvp4iIowo16bp2dxIsFFWwuqJDgNIFIcBJCjCkOt4dXDlXyYkEFp6rd3fvtFiN35KawNi+VGcm2ELZQTBRr81J5saCCN45c4PufnonZICOaE4EEJyHEqNfu9bG1q7DuR6cd+LrOeDPqtKyaEc/avFSunyqFdcXIWjQlhpSoMCqb2njneLWsJD5BSHASQoxKfr+fg+eb1MK6h6twtfes5j1vUhRr81K5fU4SUeFSWFeEhlarYW1eCr/6oITNhVKCZaKQ4CSEGFUqm9p4+WAlmwsqKK1r6d6fFGnmrrwU7spLJTPOEsIWCtFjbX4qv/qghB3FDqqd7SRGmkPdJBFkEpyEECHX2tHJ28eq2VxYwa4z9fi71p4MM+i4ZZa6mveSzFgprCtGncmxESxIj2Z/WSMvHazkX1ZkhrpJIsgkOAkhQkJR/OztKqz71tELtHT4ui9bnBHDXXlqYV2LSd6mxOi2Ni+V/WWNbC6s4Ms3ZMiaTuOcvCMJIUZUWV0LWwor2HKwkorGnsK6k2PDu1fzTosJD2ELhRia2+Yk8cSrxympbeZIhZO5aVGhbpIIIglOQoigc7V7eePIBTYXVHDgXGP3fqtJzyfnJHF3fir5k6PlL3UxJtnMBlbPTOTVw1VsLqyQ4DTOSXASQgSFT/GzvdjB5sJK3j1ejadTXc1bq4Fl2XGszUth9cxEWftGjAtr81N59XAVrx6u4rufnC6r1I9jEpyEEMPqdI2bzQUVvHSwklq3p3t/dryFtfnqobgEm5x5JMaXZVl2Em1mql3tvH+ilk/OSQp1k0SQSHASQlyzhpYOXj1UyebCSo5WOrv3R4f3FNadnSKFdcX4pdNqWJufwjMfnuGFA+clOI1jEpyEEFelo1Phw6JaNhdU8GFRLV6fuoaAXqvhxhx1Ne+bcuIx6mU1bzEx3Ds/jWc+PMP2YgeVTW2kRIWFukkiCCQ4CSEGze/3c6zSxebCCl49XEVDS09h3VkpNtbmpfLpucnESmFdMQFNjo1gcUYMe0obePFABV9blR3qJokgkOAkhLiiWlc7Lx2sZHNhBadrmrv3x1tN3DlPXc17WqI1hC0UYnS4b0Eae0ob+HvBeb5yUxZaWbT1sjo6OjAax1bZJBlDF0IMqN3r47XDVTz4h30s3rCVDW+d4nRNM0a9ltvnJPHsQwvY9dhNrL9tuoQmIbrcOisJq1lPRWMbu0vrQ92cEed2u/nsZz9LREQESUlJ/PKXv2TFihV8/etfByA9PZ3/+I//4IEHHsBms/GlL30JgB07drB8+XLCwsJIS0vjq1/9Ki0tPSWXPB4Pjz76KCkpKURERLBo0SK2bdvWffn//M//EBUVxTvvvMP06dOxWCzccsstXLhwYdifowQnIUQ3v99PwbkG1m85yoIfvc9X/vcgH512oPghf3I0/3nnbPZ/dxVPfyaPG6fFo9fJW4gQvZkNOu7ITQbghf3nQ9yakbdu3Tp27tzJq6++ynvvvcf27dspLCzsc52nnnqKuXPncvDgQf793/+dM2fOcMstt7B27VqOHDnCCy+8wI4dO3jkkUe6b/PII4+we/dunn/+eY4cOcI999zDLbfcQnFxcfd1Wltbeeqpp/jzn//Mxx9/THl5OY8++uiwP0c5VCeEoKKxlS2FlWwprKCsvrV7f0pUWHdh3Sn2iBC2UIix4975afxlTzlvH6/G2eolMtwQ6iaNCLfbzR//+Eeee+45Vq5cCcCzzz5LcnJyn+vddNNNfPOb3+z+/uGHH+azn/1s96hUdnY2v/rVr7jhhhv4zW9+Q21tLc8++yzl5eXd9/Xoo4/y9ttv8+yzz/Kf//mfAHi9XjZt2kRmplov8JFHHuEHP/jBsD9PCU5CTFAtnk7eOlbNiwXn2VPa0L0/3KgW1r07P5XFU2JljoYQQzQ7JZKcRCunqt28fKiSB5emh7pJI6K0tBSv18vChQu790VGRjJt2rQ+15s/f36f7w8fPsyRI0f461//2r3P7/ejKApnz56ltLQUn8/H1KlT+9zO4/EQGxvb/X14eHh3aAJISkqitrZ2WJ5bbxKchJhAFMXPntJ6Xiys4K2j1bR51cK6Gg0syYhlbV4qt8xKJEIK6wpx1TQaDfctSOPJ107wtwPnJ0xwGqyIiL6j183NzfzzP/8zX/3qV/tdd9KkSRw5cgSdTkdBQQE6Xd8V2S0WS/f/DYa+I3sajQa/3z+MLVfJu6MQE8DZupbu1bwrm3oK606xR7A2L4U781JlzRkhhtGa3BQ2vHmK41UujlU6mZUSGeomBV1GRgYGg4H9+/czadIkAJxOJ6dPn+b666+/5O3y8vI4ceIEWVlZA14+b948fD4ftbW1LF++PChtHwoJTkKMU842L68fqWJzQQWF5U3d+61mPZ+am8zavFTyJkXJat5CBEF0hJGbZybw+pELPL+/nB+mzA51k4LOarXy4IMP8q1vfYuYmBji4+N54okn0Gq1l32f+c53vsPixYt55JFHePjhh4mIiODEiRO89957PP3000ydOpXPfvazPPDAA/z85z9n3rx5OBwOtm7dypw5c/jkJz85gs9SgpMQ40qnT2F7cR0vFlbw3okaOroK6+q0Gq7PtrM2P5VV0xOksK4QI+D+hZN4/cgFXjlYxb/dNp1w4/j/yP3FL37Bl7/8ZW6//XZsNhvf/va3OX/+PGbzpetTzpkzh48++ojvfve7LF++HL/fT2ZmJvfdd1/3dZ599ll++MMf8s1vfpPKykrsdjuLFy/m9ttvH4mn1YfGH4wDgMPM5XIRGRmJ0+nEZrMN2/0qikJtbS3x8fFotXJa9XCT/g2u3v17uraZzQUVvHyoCkevwrrTEqyszU9hzbwU4q1SWHco5Pc3uCZC/yqKn5t+vo2y+lZ+unYO9y5IG8HHDk7/DvXzuKWlhZSUFH7+85/zhS98YdjaEUrjP/4KMU7VN3t44WAN7xYXc7zK1b0/JsLIHbnqobiZyTY5FCdEiGi1Gv5h4SR+/NYp/rqvfESDU6gcPHiQU6dOsXDhQpxOZ/dyAHfccUeIWzZ8JDgJMYZ4On18eKqWFwsq2VZUS6eiDhgbdBpW5iSwNj+VFdPiMMjClEKMCnfnp/Lzd4s4fL6J41VOZiaP/0niTz31FEVFRRiNRvLz89m+fTt2uz3UzRo2EpyEGOX8fj9HKpzdhXWbWr3dl01PCOe+henckZtCdMTYqvckxERgt5i4eWYibxy5wP/uK+eHa8b3JPF58+ZRUFAQ6mYElQQnIUapamdPYd2S2p7Cugk2E2vmpXBXbjKRmrZxPUcklNo726lursYWYyPcGB7q5lxRe2c7Ve4qkq3JmPUyn200+ezCSbxx5AIvH6xi/a3TZZ20MU5+ekKMIm0dPt49Uc2LBRXsLKmj60gcJr2W1TMTWZufyrIsOzqtpmvyZ9vl71Bcla2lW7n7b3eTbcqm2FPMi/e+yMqMleD3Q2cn+Hzq16vd/H7Q669t0+mgKzBvLd3KXX+7C5fHhc1kY8u9W9T2ilFhcUYs6bHhlNW38vqRKu5bMCnUTRLXQIKTECHm9/vZX9bI5oIK3jh6gWZPZ/dlC9KjWZuXym1zkrCZJ0a9qxHl94PHA+3t3Zun2ckTv7uD6a1tzDS0YnN5+PXxf2DuLb9H59Ph89G9KUpPhlIU9e4CX3v/X1H67h8MjUbdtFp16/3/7u/1Wjq1fn754aPkYsWjD6fFpPC1XzzE1v+zkwi7HYPVjMGoQQYlQ0er1XD/wklseOsUz+0tl+A0xl1VcHrmmWf42c9+RnV1NXPnzuXXv/51n9o0vR0/fpzHH3+cgoICzp07xy9/+cvuQn5CTGTnG1rZXFjBlsJKyht6CuumRodxV14qa/NSmBwrhXWvit8PXi/+tnY8TnXrcKmb191OZ3M7vpZ2fK0evN6+g0F1zU1EH1iMRtGjGOMI70jFh58PTM3YTF0TezUaFK0ev06PotWj6PT4tfpL7zP03efXaND6OtEqnWgCX5XOQe/TKErXE1VweZxozk8mcGJ4XNfXj9o/wmaKxK/V0WmKQAm3oLWpmz7Kgj4yAlOEHrMZTCZ1CwuD8HCIiFC/lxMyh8/d+ak89W4RhyucE2Yl8fFqyMHphRdeYN26dWzatIlFixaxceNGVq9eTVFREfHx8f2u39raSkZGBvfccw/f+MY3hqXRQoxV7nYvbx2t5sXCCvad7SmsG2HUcdvsJNbmp7IwPUYK616GokBri5/Wulba61vw1DfjaWztDkSdze10tnjwehS83kGM8Gg0+PQmOo1hKHoT7VEpnLWl4FJ8xIWnUdahRWfWc8/C2yE8HK1Rj96oxWDof/Ss94hQ7y1wVC0wUqTRXLpdvfcHRrR6f1UU8HkV/J0+lI5O9K0tHGz7XzztHZi9WiwdGuw+I5aYeDTtXvD5MLS5oM0F9V2PAXiBdoOZOpMFr9lCp8mCt2vzGcxodRrCw3uCVO//22xgtarfS7ganFiLidUzE3m9a5L4j+4c35PEx7MhB6df/OIXfPGLX+Shhx4CYNOmTbzxxhv84Q9/4LHHHut3/QULFrBgwQKAAS8XYrzzKX52naljc0EFbx+vpt2rjhZoNHBdpp21+Smsnpk4IVYVvhy/H9raoLkZWlrUrc3lxVPfTEdjC97GZjqbmlFczeg7WnqNulyaz2BC0ZvQhJnRW/puBmvX1wgjRpMGoxGMRnWkJbzqIR589X4SwiejeIv4270vsjIjKvidMGjars0AhPHH2eu46293Udc1x+npwBwnvx+luRVvYzMdDc14G9Wt09lCZ4uHjo52vN52vN46Otqhw6UeufR0qqNUXpMFj8lCs8lCR3gUnaa+I6A6HVgsaogKhCmrFaKiIDJSvVz0+MwidSXxlw9Wsv626VhkkviYNKSfWkdHBwUFBaxfv757n1arZdWqVezevXvYGyfEWFZS28zmwgpePljJBWd79/6MuAjW5qVy57wUkidQYd3OTjUMud1qOOre3H7a6lvxNLSga2vG4FE3vacZndfT5z50XZtWC8ZwLbpIC/poC8bIcIw2M0abGVOk+tUcacIcrsVsZsjze+6IW0HV9DOcLj/N1ElTR/1ZdSszVlLzaE3/s+o0GrTWCEzWCEyTEvreyOu96AfRtbW2onT68HhcXRu0e7qmgrUZcGmjaCKKJn8knrAonL4wnM7+bdJoekJUVBRER/d8NU7QlTOWZMSSERdBqaOFlw5W8rnFk0PdJHEVhhSc6urq8Pl8JCT0fQEmJCRw6tSpYWuUx+PB4+l5w3S51FWRFUVBGcRfmYOlKAp+v39Y71P0mIj929TawWtHLrClsJLDFT2fJpFhBm6fk8TavBTmpkZ2r+Z9LX0z2vrX71eDkcvVd3O71c3T0tkdinpvek8LFr+CBfXD1mRCnXcTrX41WM0Yoi2YYiIwxVow2y2YYi1owsMGcZxI7Zur6SKj1khCRAJGrXHU9PHlGLVG0iPTgUH+Xul06rBQ5EVzbfx+aG3F1NyMKRCm3G5wOkHxADVADX6/Op++1WfCrYvCrY3EqYmiQYmiocVERwc0NanbxaxWiInxo9XqyMpSiItTR64mgn9cNIkfvH6SP+8q4zMLUoO2sn+w3h/Gwmsh2EblOOGGDRt48skn++13OBy0t7cPcIuroygKTqcTv98v6+AEwUTp306fn93nnLx5op4dZ514feokFZ0GFqdH8skZsSybEolRrwU6cDgcw/K4oehfRYHmZg0ul4bmZi1utwa3W/1/c7MGn0+9nkbxYWx3Y25vwtTmxNzmxNbRgk4HZrMfk8mvfo1SvzeHazDGhGOMCYeIcPwREd0b+p63qY6ujZZmdQvqc50Yv7+XFBgyslohKQkUBU1zMxqnE63LpX71tqD3+4n21RLd66Z+i5lWow2XJoomImlQonG2Gmlq0tLaqsHthspKP21tnRw+3IxGo8Fk8hMd7ScuzkdsrILdrhA2Dgdkl6caMeu1nK5t5t2DpcxLtQblcYL1++t2u4ftvsaqIQUnu92OTqejpqamz/6amhoSExOHrVHr169n3bp13d+7XC7S0tKIi4sb9iK/Go2GuLi4ifnGGGTjvX9PVLnYfLCSVw9VUd/S0b1/epKVu+al8Om5ycRZTUF7/GD2b1ubOsAQGDEIbG73AJOaFQWjx018WyPm9iaiaMKmcRMe5ic8Sp1AHBYGZnMYBotJ/SCOiFCHGAJb2GBGj0bWeP/9HRY+nzqs2PuXpFkNtFF4SO4anUILJETAtCg6wqNo8EVS026ltNyHz2elqUmDovTMbSsrU+/eaoWEBIiPh8REiI0ddb8mQxYPrJnXwPP7z/NGkZvVeZlBeZxg/f6azbK46pCCU6DuzNatW1mzZg2g/nC2bt3KI488MmyNMplMmEz9P3C0Wu2wv4FpNJqg3K9Qjbf+dbg9vHKokhcLKjhV3fOXl91i5I7cFNbmpTIjefjC/ZVcS/8qSt/PvN5ByeMZ+DYa/IT5monVNRGtaSLS34RV4yIiWiEsBcymwHwiDZjMPRNcIiPVrwO8rkez8fb7O+y0WjXNxMb27Ovs7J+6W1vVNN7WhpkLJAOJisJkjY+onCz8sfE0amNxNBmorYXaWmhsVENUaam6gTo3KilJ3ZKTx26Q+tySyTy//zxvH6+mrrmDeFtwwkgwfn/ltXAVh+rWrVvHgw8+yPz581m4cCEbN26kpaWl+yy7Bx54gJSUFDZs2ACoE8pPnDjR/f/KykoOHTqExWIhKytrGJ+KEMHR7vWx9WQtWwor2Hbaga9rOW+jTsuqGfGszUvl+qmjt7Cu36+OFDU09GyNjV1TVi4zXcFqhVhzC7E6dRQp0t+ExefEbPD1v7LB0BOSAkFpPB5nEVem1/cPU15v/+HL1lY0zc1w9iy6c+ewA/bISKbH2WG6nQ5LDLUN+u4gVV0NHR1w7py6gRqkkpMhNRXS0tTf2bFgZnIk+ZOjKTjXyPP7z/PVldmhbpIYgiEHp/vuuw+Hw8Hjjz9OdXU1ubm5vP32290TxsvLy/sk0qqqKubNm9f9/VNPPcVTTz3FDTfcwLZt2679GQgRBH6/n4Pnm9hcUMFrh6twtfes5j03LYq781P51JwkosJH1+lBLS1qKOodkpqa1EGAgej1vfKOTSGGBqI667B0NqFvblI/8AI0qIdcdLr+I0kRslCnuAyDAeLi1C2gtRVvcbH6/4YG9RCf06luZ85g1GhIjYoi1W6H+XaUyGjqm3RcuABVVXDhghqkysp6Du1FRcGkSWqISkwc3cshfG7xZArONfLc3nL+dUUm+lH6h5foT+P3D7YAQOi4XC4iIyNxOp3DPseptrZWiqQGyVjs36qmtu7CuqWOlu79SZFm7pyXwl15qWTFh/70H58P6uoUTp+ux++PpalJS0OD+kEyEJ1OPQ08JkbdoqMhOlLB0tkE9fVQV6d+eF08BKXV9oSjwFeLZWweHxmisfj7O5b069/29p7fxbo69fBeb1qt+otrt4PdjmKLor5RS2UllJdDTU3f+Xd6vRqgpkxRw9RoWwLB0+lj6YYPqG/pYNM/5nHLrKRhvf9g/f4G6/N4LBmVZ9UJMZJaOzp553g1mwsq2XmmrvvN12zQcuusJNbmpbIkMxZdiFbz9nh6Pk8CX5ua1PDkdhuxWnvWKdJo1HwTCEiBkGSzqfOTcDrVO6iqh6P1dJ8GF2A2qx9MMTFqSOp950IEk9kMKSnqBmpw6h2kAsGqvh6KitDqdMTFxBBnt5N7vZ2OsEgqKjWcPw/nz6s3P3tW3bRa9XDelCkwebL6UKFm0uu4b0Ea/7XtDH/ec27Yg5MIHglOYkJSFD/7yhrYXFDBm0cv0NLREyAWTYlhbX4qt81OGvGVfZub+wak+vruk5T6MZvBavWRkdE363QfnghMbqqrg9NdHzi9D72B+md411/wxMZOnMV0xOgXqPGSlqZ+39LSE6Lq6tThVYdD3QCjXk9GbCwZaXaYZ6euw9YdnJqa1FGp8nL1j4u0NMjOVkOUPoSfgp9ZNInffHSGnSX1lNQ2j4rRbHFlEpzEhHKuvoXNhZVsKaygorGte/+kmHDuylPPikuLGZlVoltbe973A9ullimz2Xrm2wYyTlgY1NZ2EB/fa1Do4uR18bE7g6HvHVmtE+KwmxgHIiLUbXLXatuBPwoCv+9er3q8rmu5HHtYGPbERBbclEijJoaz57SUlqpHpAMhymhUR6Gys9Uz9Ub6pZAaHc7KnHjeP1nLn3eX8eQds0a2AeKqSHAS456r3cubRy6wubCC/WWN3fstJj2f7CqsuyA9Omgr+IJ6uO3ikNTS0v96gWkcvQNSbOzA8zMUBTV9lZernwb19f2Tl06nDkUFRpUiIyUoifEhsDjnlCnq6KrL1TdItbV1H6uLNhiIjo8nb2kiTcZ4Ssr0nD6t/p1RVKRuFgvk5Khb+AhW2Pn80im8f7KWFwsq+ObqadjMhpF7cHFVJDiJccmn+NlRohbWfed4NZ5OddKzVgPLsuNYm5fCzTMSCTMO/2k3nZ3qe3dtbU9I6qoa1E90dM/JRnFxaki65JlAvU/pdjqhoQFTdbUahgJDTlqtGpQCySsqSuYoifEvMLkvMhIyM9W5ew6HOvoUWMegshIqK4nSapkfG0v+kkSq/QkUV4RRWqqGqAMHoLAQ0tNhxgx1qYNguy4rlqx4CyW1zbx4oIJ/WjYl+A8qrokEJzGuFNe4ebGrsG6Nq2cVx+x4C2vzU1mTm0Ji5PDODHW51JAUOEow0MlpoB5uCwSk+Hg12xgu9cdlYBHB3gsJXjxEpSjqB0ZMjHqndruaxEbzOdhCjASdTl2PIDER5sxR1+gIhKjmZnA40DgcJHGUpMhIli5M5JwnkWPlNmpqehbdjIqCmTNh2rTgzYXSaDR8fmk633v5GH/cXcbnl6ajDdGJKGJwJDiJMa+xpYNXD1exubCCI70K60aFG7hjbjJr81OZnRI5LIfiOjt7/pANhKW2tv7XCw9Xw1Hv0aRLLpqtKD0BKfD1UvWgwsN71lCy2dRi2MnJMqokxKUE/riIiYHp09XgFAhRDQ3gdKJ3OsmkiMyIMJpmJHKqKZGTNTE0NWnZuRMKCtQRqFmzgnNG3l15Kfzk7VOcq29l2+labspJGP4HEcNGgpMYkzo6FbYV1bK5sIIPTtV2F9bVazXcmBPP2rwUbsyJx6S/ttEXt1t9fw2EpPr6/rXatFp1sCc+Xq2rlZBwmZPT1Cq5fVdQdrkGKACH+g7dezXuqKi+Q1SKojZMCDF4gfqImZnq5MPAULHDAW1tRLWdZTFnmZ9g4FxbPEcdiTha4iks1HP4sDr6NGeOOoI8XMKNev5hQRq/336WZ3eWSXAa5SQ4iTHD7/dzvMrFiwUVvHq4ioZehXVnpdhYm5fKp+cmE2u5unpofr86ol9dra5KXF098ATu8PCegJSQoIamAY+O+f09qyH3nps00HE8o7F/SBpjdd2EGHNMJnV1zEmT+s2L0nd0kGmuJCO1kmqHliJHLFX+JE540zh5UsvUqZCXN3xlXh5Yks7/23GW7cV1lNS6yYofI/VjJiAJTmLUq3W18/KhSjYXVFJU03MIK85q4s556hIC0xKH/iajKOr7ZCAo1dT0L24bGE0KhKT4+MuMJrW09D3c5nQOXOvEYOhZhTuwSV03IULrEvOiNNXVJGmaSYp30NDgoKSqhNO66RQVJVNcrI5AzZt37UugpcWEs2p6Au+dqOGPu87xH2tkaYLRSoKTGJXavT7eO1HD5sIKthfX9RTW1Wv5xIwE7s5LZXm2fUj1nQLLvFRX9xx+uzjX6PVqQEpMVNd1iY+/xKTQ9vb+RUsvXlwS1Dfji0NSeLgsCSDEaDbQvKjqamLOnmVhTCvZTQWcrD7LacNMTp6MoqhInUSel3dtA8UPLU3vft97dPU0IsNkaYLRSIKTGDX8fj+F5Y28WFDJ60eqcPcqrJs3KYq1+ancPjuZyPDBvZl0dKgBKVAQtK6u/1Qis7nnj8zERHV0qd88a4+n7+G2pqb+Q1Og3tBm6xuSJkhdNyHGNYsFsrLUNaPOnCG6pISlUQ3kNGznaGMqJfocjh4No7gY8vPVrHU152ssyYxlaoKF0zXN/P3AeR5enqjxNoQAAGMhSURBVDH8z0VcMwlOIuQqGlt5qbCSLQcrOVvXM6koJSqsq7BuChlxVx4H7+zsCUpVVephuIuDksWijiQFRpSioi66E68X6pv6BqWBTpvTaNTJDb1DktR1E2J80+lg6lR1TtSpU8RwnhtiKpjRcIEDTZlU+DLZuVPPiROwZIlaH28o1KUJpvBvLx3lf3aV8dB1U0JWI1NcmgQnERItnk7eOlbN5oIKdpfWd+8PN+q4ZVYid+elsjgj9rLrmXR2qofeegeli+dd22zq2frJyWpY6jMPobMTGlx9R5IGmg0O6g17hySbTdZLEmKiMpshN1cdgTp+nDjqWR11mvOOcva7c2jwp/LmmxqmTIHrrhvaSuR3zkvhZ++coqKxjXePV3PrbCn+O9pIcBIjRlH87Dlbz4sFFbx9rJrWXoV1l2TEsjY/lVtnJRJxicK6Pp86LykQlGpq+gcli6UnKCUn9wpKgbWSynqNJDU3D7wMQO+1kqKi1DlKoawEKoQYnSIjYelSqK5Ge+IEk7UtJMcc4nR1KQXtMzl71k5lJSxapJZyGcxR+zCjjs8umszTH5bw3zvOSnAaheTTQATd2boWXjpYxUsHK6ls6jnslR4bztq8VO7MSyE1uv+fZH6/uj5dRYVaLaG6uv9k7vDwvkHJZqNnraSGJihtGtpaSZGRAxeGE0KIS0lMVM8kOXsWQ3ExM9NcpLl2U1CZyNmwGWzfHkFxMVx//QDTAwbwwJLJ/PbjMxw418jB8kbmTYoO+lMQgyfBSQSFs83La4cqeWFfGUcv9Bz+spr03D43mbvzU8ib1L+wbkuLGpIqKtTt4pq1YWF9g1Kkzd+zDEB509DWSoqMDM4ywEKIiUerVRfVTEuD06exlZWxwlpNxvkaCmqmUOObypYtBhYvVlchv5x4m5lPz01hc2EF/73jLE9/RoLTaCLBSQybTp/C9pI6Xiyo4L0TNXT0Kqx7/dQ41ual8okZCZgNPXODvF71jLfAqFJjY9/71OvVgJSaCikpEG1s6Zm4fbxJ1koSQowuRqNamyU9Hc2JE0zW1BAfV8rRU+c5o5/Gjo8nU16u5YYbLv+W9IVlU9hcWMFbx6qpbGojJUrev0YLCU7imp2qdrGlsJKXDlbicPecpj81wcLqqZF89rqpJEaph+L8fnWeUmBUaaB5SvHxakhKtbeTYGpC62pSg9LeJlkrSQgxNlgssHAhOByEHT/OArOb+HPHOF58FkfzTF50JHDjjZc+825Gso2lmbHsOlPPH3eV8W+3TR/Z9otLkuAkrkp9s4dXDqmFdY9Xubr3x0QY+fTcZO7OT2V6ogWHw4FFb6aoCM6fVwPTxUsgWa2QFu8h1eokObwJY2sTNDZBtayVJIQY4+Li4IYb0JSXk24uIja2hSNH9uFw2HmvYSY5S0zEZ1WSYkvGrO87deDh5VPYdaae/91bzldXZmO5xIkzYmTJT0EMWkenwgenanixoJJtRbV0dq3mbdBpuCknnrV5qayYFo9eq6W2Fg4cUDh61ERnZ9/ljUxaL5MinaRamkgKa8LS2QStbdB60QPKWklCiPFAo4HJkyElBWtJCYstZyg6WceuA3/ha6/u4HCCA9OMg7z0mRdYmbGy+2YrpsaTERdBqaOFv+0/zz8tmxLCJyECJDiJy/L7/RytdLK5oIJXDlfR1NpzqGxOaiRr81L51NxkzBojFRXw8Tb1EFxHR9fJbU4/sfoGksNdpFmbSAxrIkrfomafTsDd68FkrSQhxHim10NODrpJk8hMOMQTu79OQnMmK906jjiXcqf3IWr//XT3yJNWq+ELy6bw3ZeO8YedZ3lwabosiDkKSHASA6pxtfPSwUo2F1RQXNvcvT/BZmLNvBTWzkslUmOlvBy2vaOWM9EoPgxtLkxtTcR0OkmJaCBce4EpkyyYzReNEslaSUKIiSo8nMqpibyfU8rM8Hqiy+bS2hmP+/BNHCquYfH0yd1XvWteKk+9U0RFYxtvH6vmk3NkXadQk08q0a3d6+Od49VsLqxkR7GDriNxmPRabp6ZyKdmppBmjKOqUsPutxT8TnU+krHNSVJbE7FGN3F2P/Y0iIoEv1/B6fRhtJnVYpmyVpIQQgCQbE1GibKxK8xFVNIeGquiMXsmc/DjZOJNkNFVpi7MqONzS9L51dZifvfxGW6bndhvGRcxsiQ4TXB+v5/9ZY1sKazgjSMXcHt6Tu2fPzmaW6amkRMej6usnbo3nbhaj2JsbSLe48aoU7DbwZ6iFsc1mVD/6QpHfpsNj8ej1nWSeUlCCNHNrDez5d4t3PW3u2i0ubDGfMx3U7ei8xh4/31YvBjmzFGv++CSyfz2ozMcrnCyp7SBJZmxoW38BCfBaYI639DK5sIKthRWUt7QMys72Wrm9sQY5ukjoMaD9+0y3O1H0CoKMajTjuzJEGeHyDgj2piovksB9F5QUlHUtQeEEEL0szJjJTWP1lDlriLZmoxJZ2bXLjh+HPbsUZeoy8uDWIuJe+an8pc95fzu4zMSnEJMgtME0uzp5M2jF9hcUMHesw0AGDu9JLhq0TmPYnFXcl/CKlKq0rpvY9aqR9nikg3EZUcRnhQpC0oKIcQwMevNZERndH8fKAq8fz8cOKD+/Tl/Pjy8LIO/7i3nwyIHp2vcTE2whrDVE5sEp3HOp/jZfaaezYVqYd02r1pY1+/RM8OawKni50g4fww/PkDDm41v8aXFXyQuK4747EgSpkVhsEdCRERon4gQQkwQ8+apJxTv2QOFherCwQsWRHDLzETeOlbN7z4u5al75oa6mROWBKdx6oyjmc0FFbx8sJIqp1rwzddiJEETx9zoFKYlxuD1O3m/vYFkg54mSydNsTU0xVXx0+9tJDM2M8TPQAghJq45c9Spobt2wcGD6vk0X7o+g7eOVfPKoUoevXkaiZFSazMUJDiNI02tHbx2RD0Ud+h8E34/+JpNmNrszLIlMzslhrTocDQaDVotxMRFYso+xq6wk2B2oUGD1WQlJTIl1E9FCCEmvFmzwOeDvXvV7frro1k4JYZ9Zxt4dudZ1ksZlpCQ4DTGeX0KH592sLmwgvdP1OLx+vG5zSiuWLLC45mbFENOkg2DToter57glp6ufjUajUTO/hF3/e0uXB6wmqxsuXdLv2X/hRBChMbcudDeDocPw/btcGdWFvvO7uO5veX8n5uysJkNoW7ihCPBaYw6UeVic2EFrxyqxOH00ukKo7MphjhtFHmpMcydHoXVbMBsVlf6nzJFLZx78ULcF5/VIaFJCCFGl0WL1PBUVAStZXbSLVGUNTfx3N5yvnyDTKsYaRKcxhCH28MrhyrZXFjJ8fJmfM5wOp2RmL0W8lOiyMuPIjkqHItFHVVKT4fExCsvoXTxWR1CCCFGl+XLwe2GqioNc8mh1LuP/95xls8vTcdskNJUI0mC0yjn6fSx9WQtmwsq+OB4PZ6GMDqd4Whao8lJtJI3M5qpiRZiY7RMmaKGpbi4ULdaCCHEcNJq4ROfgJdegmm+aMJPJ1Orr2BzYQWfXTT5yncgho0Ep1HI7/dz6HyTeihufw311QY6m8LxtSSTGh1OfmYUc9KimJyi7w5LUVGhbrUQQohgMpngllvgpZe0LEpM4d1qN7/9qJT75qeh10l1hpEiwWkUueBsY0thJX/fXcXpM/6usBRPpNlA7qQo8iZFMyvLTEaGWsfIYgl1i4UQQoykqCi4/npoaYvhw6IYSssu8MbRC9yRK2dDjxQJTiHW2tHJO8er+dvuC3xc2Iq3MRxfSxQGnZbZyTbycqNZOstCVpaGKVMkLAkhxESXmQm5c7QsLY7l/eIOnn6vlE/PTZbivyNEglMIKIqffWUN/O/OKl7f4cRdZ8bXYgJMTLFHkDctmpvm2ZiZo5ewJIQQop8lS6D0XCwfFzs4UmDgg1O1rJyeEOpmTQgSnEbQufoWnt9TxQtb66k4p+sKSzZiIozMmx7N6vwoFuWamDJFKpwIIYS4NJ0Oblut5+W9sXx0WuFnL1Zw0/fiZdRpBEhwCjJXu5fXCi/wl/fqKTzmpdNtBsIx6XXMmxzJJ+ZHsnqxhYwMjYQlIYQQg2a3w5fvimHnT+s5sFfHjlMNLJ8eG+pmjXsSnILAp/jZdqqOP71by9Z9LbQ1msGvQ6PRkR1vYcXcSO5aEcXMHJ2EJSGEEFdt1fUmlr5h5eOjTn705xre/k8JTsEmwWkYFV1w84f3qnn1YxeOKj1+RQOYibeauW6GjXtvimZRronIyFC3VAghxHig1cL6B+PZ8S0X+ws72X7UyfLZ8iETTBKcrlFDcwd/+bCGFz5opKhYwd+pBQyEG3XMz7KxdkUUtyy1YLfLcWchhBDDb+GsMK7PC2NbQSv/8Yda3v2lBKdgkuB0Fbw+hVf31vGXdxrYfagdr0ddeEyn0TF9UgSfXm7jnpuiSUvWIfP0hBBCBNu/fyGRjw6WUnCyja373dyYL/NAgkWC0yD5/X72l7h49i0H7+xqwdkUSERaUmNN3LLYxmdvjmFWtumKteGEEEKI4ZSbYeGGRUa27e7gqedquTF/SqibNG5JcLqCyoZ2nn3LwUvbnJSdV7r2arCG6blxfgT/eHMMK/Ks6KTGohBCiBD63ueS+WjvWfafauHjwhZyUkPdovHpqsZGnnnmGdLT0zGbzSxatIh9+/Zd9vp///vfycnJwWw2M3v2bN58882rauxIafX4ePbdam759klyP3eaX/65kbLzCnqtlkUzIvj5V5M58VwOz353MisXSGgSQggRevMybFy3wIjfD0895wh1c8atIY84vfDCC6xbt45NmzaxaNEiNm7cyOrVqykqKiI+Pr7f9Xft2sX999/Phg0buP3223nuuedYs2YNhYWFzJo1a1iexHDw+hS2Hmziufcb+XBfC62tPZdlpJi443obn7/FTmqCIXSNFEIIIS7j3z+XzC37y9hzspnC0wZu6f+xLK6Rxu/3+4dyg0WLFrFgwQKefvppABRFIS0tja985Ss89thj/a5/33330dLSwuuvv969b/HixeTm5rJp06ZBPabL5SIyMhKn04nNZhtKcy+rvrmdF7eX8sFBDXsOemh29wzAxVh13LzEwoO32Fk4QybZXQ1FUaitrSU+Ph6tTPwadtK/wSX9G1zSv8Fz6/oT7DvYybI5Bl768bRh7d9gfR6PJUMacero6KCgoID169d379NqtaxatYrdu3cPeJvdu3ezbt26PvtWr17Nyy+/fMnH8Xg8eDye7u9dLhegvtAURbnUzYbk/71bxeP/fQGv29S1R4vFpGPBbBP3rYzijuui0es13Y8rhk5RFPx+v/RfkEj/Bpf0b3BJ/wbPt+9P5O6DFew66uXkuRamTx6+P/7l5zXE4FRXV4fP5yMhoW8hwYSEBE6dOjXgbaqrqwe8fnV19SUfZ8OGDTz55JP99jsc/7+9Ow9vqkofOP5N0jbpvu8rhbKVnQKyKCoIMggiKoiM4DLj6ICC6AygI4iOgo6MKKCOzrjMT3EdXEBBEUFE9h26Q0tbaJPubbq3yf39cW2hbLbQkC7v53nuA01vbt68TXLfnHPuOXlUVVU1J+SL8nWwUmvW4+/iQL+ujtw0yIkbBzrhbNAAdRQWSv/wlbJarZSUlKAoinyjtAHJr21Jfm1L8ms7PQKgeycNSekKKz7N4rmZPi12bLPZ3GLHaqta5VV1CxcubNRKVVpaSnh4OP7+/i3WNDhxpIKrgy+dQ8106uQnb1wbsFqtaDQa/P39Jb82IPm1LcmvbUl+bWvRfY4cTilg9u1RGPQtd6o3GAwtdqy2qlnZ9PPzQ6fTYTKZGt1uMpkICgq64H2CgoKatT+AXq9Hr9efd7tWq22xN5hWC2OucyY319yixxWNaTQaya8NSX5tS/JrW5Jf27kpzpu+EbUY9A4tml/5WzVzOgInJycGDhzI5s2bG26zWq1s3ryZoUOHXvA+Q4cObbQ/wKZNmy66vxBCCCFEa9Xs9rt58+Yxc+ZM4uLiGDx4MCtWrKC8vJz77rsPgBkzZhAaGsrSpUsBmDNnDiNHjmT58uWMHz+ejz/+mH379vHWW2+17DMRQgghhLCxZhdOU6dOJS8vj0WLFmE0GunXrx8bN25sGACemZnZqClv2LBhrFmzhr/97W88+eSTxMTE8OWXX7aqOZyEEEIIIZqi2fM42YOt5o2QeURsS/JrW5Jf25L82pbk17ZslV+Zx6mVXlV3rvrarn4+p5ZitVoxm80YDAZ549qA5Ne2JL+2Jfm1Lcmvbdkqv/Xn4TbQ5mIzbaJwqp83Ijw83M6RCCGEEMJsNuPp6WnvMOyiTXTVWa1WsrOzcXd3R6PRtNhx6+eHysrK6rBNjrYk+bUtya9tSX5tS/JrW7bKr6IomM1mQkJCOmxLYZtocdJqtYSFhdns+B4eHvLGtSHJr21Jfm1L8mtbkl/bskV+O2pLU72OWS4KIYQQQlwGKZyEEEIIIZqoQxdOer2exYsXX3B5F3HlJL+2Jfm1LcmvbUl+bUvyazttYnC4EEIIIURr0KFbnIQQQgghmkMKJyGEEEKIJpLCSQghhBCiiaRwEkIIIYRoIimchBBCCCGaSAonIYQQQogmksJJCCGEEKKJpHASQgghhGgiKZyEEEIIIZpICichhBBCiCaSwkkIIYQQookc7B1AU1itVrKzs3F3d0ej0dg7HCGEEKJDUhQFs9lMSEgIWm3HbHtpE4VTdnY24eHh9g5DCCGEEEBWVhZhYWH2DsMu2kTh5O7uDqh/KA8PjxY7rtVqJS8vD39//w5bOduS5Ne2JL+2Jfm1Lcmvbdkqv6WlpYSHhzeclzuiNlE41XfPeXh4tHjhVFVVhYeHh7xxbUDya1uSX9uS/NqW5Ne2bJ3fjjxsRl6tQgghhBBNJIWTEEIIIUQTSeEkhBBCCNFEUjgJIYQQQjSRFE5CCCGEEE0khZMQQgghRBO1iekIhBAC4EReGf+3MwOAAA89ge4GAj0M9Ah2x9dNb+fohBAdgRROQohWr6y6jpWbU3nnl3RqLcp5vzc4all+Zz/G9wm2Q3RCiI5ECichRKulKApfH87m+W8SyTVXA3BDN3+6B3tgKq0it7SajMJysgormbXmACmmGOaMikGr7biT8wkhbEsKJyFEq5SYU8rir+PZk14IQKSvC4tu6cmoHoGN9quzWFm2IYl/b0/n1c2ppJjMLJ/SFxcn+XgTQrQ8+WQRQrQqJRW1vPJDCv/deRKronbDzb6hC3+4NhqDo+68/R10Wv52S0+6Brnz1BdH2XDMyMmCCt6eMZAwbxc7PAMhRHsmhZMQolWwWhU+25/FSxuTKSivAWB872CeHN+DUC/n37z/lLhwov1ceeiD/STmlHLrql944/cDGdzJx9ahCyE6EJmOQAhhd4ezirnt9V+Y/7+jFJTX0CXAjQ//MITV0wc0qWiqFxflw1ezRxAb4kFBeQ3T/72Lj/Zk2jByIURHIy1OQgi7KSir5h/fJfPJviwUBdz0DswZFcO9w6Nw1F3e97pQL2c+f2gYT3x+mG+O5LBw7VGSckr52y09L/uYQghRTwonIcRVV2exsmZPJi9/l0xpVR0AkweEsuDm7gR4GK74+M5OOlZN60+PIHde/j6F93dmkGIq4/XpA/B2dbri4wshOi4pnIQQV9We9EIWfXWMJKMZgJ7BHjx7ayxxUS07Fkmj0TD7xhi6Brrz2CeH2JlWwMTV23l7Rhzdgzxa9LGEEB2HtFsLIa4KU2kVcz8+yJR/7STJaMbT2ZHnbo1l3SMjWrxoOtuY2CDW/nk4ET4uZBVWMvn1HWw8lmOzxxNCtG9SOAkhbKqmzspb205w48tb+fJQNhoNTBscwZYnrueeoVHorsJkld2C3Pl69nBGdPGjosbCQx8c4JVNKVit589CLoQQlyJddUIIm/k5NY9nvo7nRF45AP3CvXj21lj6hHld9Vi8XJx4775BvPBtEu/8ok6WmZhTyj+n9sNNLx+FQoimkU8LIUSLO1VUwd/XJ7Ix3giAn5sT82/uzu0Dwuy6HIqDTsuiCT3pEezOU18c4/sEE7et/oW3Z8QR5edqt7iEEG2HFE5CiBZTVWvhrW1prN5ynOo6KzqthhlDI5k7uiuezo72Dq/BnXHhdAlw46EP9pOaW8bEVdtZefcARnb1t3doQohWTsY4CSGumKIobEowMeaVbfxzUwrVdVaGdPLhm0dHsHhCbKsqmur1j/Bm3ewRDIjworSqjvve3cObP51AUWTckxDi4qTFSQhxRdLzy3l2XTxbkvMACPIw8NT4HtzSJxiNxn7dck0R4GHgowevYdGX8XyyL4tlG5KIzy7lxdt7Y3CQ75VCiPNJ4SSEuCwVNXWs+vE4//45nRqLFUedhgdGRPPIjV1wbUODrfUOOpbd3pteoR4sWZfAusPZHM8t483p/dHbOzghRKvTdj7dhBCtgqIofHM0h+e/SSSnpAqA67r6s3hCTzr7u9k5usuj0Wi4Z2gU3YI8+POHvy4SvHoHz42LYnxAgL3DE0K0IlI4CSGaLMVkZvFX8exMKwAgzNuZRbf05Kaega2+W64pBnfy4evZI3jog/0cOVXCnC9SyanS8cdro9vF8xNCXDkpnIQQv6m0qpZXf0jlvR0nsVgV9A5aHhrZmYev74zBUWfv8FpUiJczn/5pKE99cZT/HTjNC98mcex0KS/e3gdnp/b1XIUQzSeFkxDioqxWhbUHT7NsQxL5ZdUAjI0N5G/jexLu42Ln6GzH4Kjjpdt7E+Wh5dVtp/j6cDapuWW8dc/Adv28hRC/TQonIcQFHTtdwqKvjnEgsxiAaH9XnpkQy3UdZK4jjUbDnf0CGBQTwqw1B0nMKWXCqu2smjaAETF+9g5PCGEncr2tEKKRovIanvriKBNWbedAZjGuTjoWjOvOxjnXdZii6WyDO/mw7pER9A3zpLiilhnv7Jb5noTowKTFSQgBgMWq8NGeTF7+PpniiloAbu0XwsJxPQjyNNg5OvsK8XLmkz8NZdFXx/h03ymWbUji6KkSXrqjT5uaekEIceUuq8Vp9erVREVFYTAYGDJkCHv27Lnovm+//TbXXnst3t7eeHt7M3r06EvuL4S4+vZnFDFx1Xb+9uUxiitq6R7kzicPXsOrd/Xv8EVTPYOjjhdv78PfJ/XCUafhm6M53Pb6L6Tnl9s7NCHEVdTswumTTz5h3rx5LF68mAMHDtC3b1/Gjh1Lbm7uBfffunUr06ZNY8uWLezcuZPw8HDGjBnD6dOnrzh4IcSVyTVX8finh7n9jR3EZ5fiYXBgycRY1j8ygiHRvvYOr9XRaDT8/ppIPn7wGgLc9aSY1HXuNiea7B2aEOIq0SjN7KgfMmQIgwYNYtWqVQBYrVbCw8N55JFHWLBgwW/e32Kx4O3tzapVq5gxY0aTHrO0tBRPT09KSkrw8PBoTriXZLVayc3NJSAgAK1Whnu1NMmvbV1JfmstVt7fcZJXf0jFXF0HwNS4cP5yczf83GS+bPjt/OaWVvHnDw+wL6MIgEdHxTB3VAxarcz31BTy+WBbtsqvrc7HbUmzsllTU8P+/fsZPXr0mQNotYwePZqdO3c26RgVFRXU1tbi4+PTvEiFEC1ix4l8fvfqz/z9m0TM1XX0DfPkiz8P48U7+kjR1AwBHgbW/PEaZg6NBOC1zak88P5eSn4dHyaEaJ+aNaoxPz8fi8VCYGBgo9sDAwNJSkpq0jHmz59PSEhIo+LrXNXV1VRXVzf8XFpaCqgVtNVqbU7Il2S1WlEUpUWPKc6Q/NpWc/ObXVzJ0g1JfHPUCICPiyN/ubkbdw4IQ6vVyN/pHE3Jr4MWFk/oSZ8wT5784hhbkvOYsOpn3pg+gB7BHfPbeFPJ54Nt2Sq/8ve6ylfVLVu2jI8//pitW7diMFx8wOnSpUtZsmTJebfn5eVRVVXVYvFYrVZKSkpQFEWaim1A8mtbTc1vTZ2VNQdMvLfHSFWdFa0GJvfx58GhIXgYHMjPz7uKUbcdzXn9Dg915K0p3Viw/gSZhZVMfmMHC0ZFMq6HjBO7GPl8sC1b5ddsNrfYsdqqZhVOfn5+6HQ6TKbGAyFNJhNBQUGXvO/LL7/MsmXL+OGHH+jTp88l9124cCHz5s1r+Lm0tJTw8HD8/f1bfIyTRqPB399f3rg2IPm1rabkd2tyHkvWJ5NRUAFAXKQ3Syb2lNaQJmju6zcgAL6JDuGxTw/zU0o+S747SVqJlad+1wMnB3n9n0s+H2zLVvm9VKNHR9GswsnJyYmBAweyefNmJk2aBKh/nM2bNzN79uyL3u+ll17i+eef57vvviMuLu43H0ev16PXnz/WQqvVtvgbTKPR2OS4QiX5ta2L5TejoJzn1ifwQ6J6tWuAu56nxvdgYt8QWay2GZr7+vVxM/DOvYN5dXMqr21O5f92ZRKfXcrr0wfKtA4XIJ8PtmWL/Mrf6jK66ubNm8fMmTOJi4tj8ODBrFixgvLycu677z4AZsyYQWhoKEuXLgXgxRdfZNGiRaxZs4aoqCiMRnV8hZubG25ubi34VIQQlTUWXt96nH9tS6OmzoqDVsP9Izrx6KgY3GSixqtCp9Uw76au9A3z5LFPDnEgs5hbVv7MymkDGNpZuu6EaOua/Uk6depU8vLyWLRoEUajkX79+rFx48aGAeOZmZmNKtI33niDmpoa7rjjjkbHWbx4Mc8888yVRS+EAEBRFDYcM/L8N4mcLq4EYEQXP56ZGEuXAPmCYg+jegSy7pER/On/9pNkNPP7/+zmr2O78eB10dLqJ0Qb1ux5nOxB5nFqmyS/tlWf31JcWLI+gV+OFwAQ6uXM07f0YGxskJygr0BLvX4rayw89eVR1h5QJ/29OTaIf9zZB3eDY0uF2ibJ54NtyTxOtiNt90K0UeaqWl7bdopPD+VSZ1VwctDyp+ui+fP1XXB20tk7PPErZycdy+/sy4AIb5asi2djvJEUk5k3fj+QbkHu9g5PCNFMUjgJ0cYoisKXh06z9Nskcs3qfGejewSy6JaeRPi62Dk6cSH1S7X0CvXkzx/sJy2/nEmrf+GFyb24rX+YvcMTQjSDFE5CtCHx2SU883U8e0+qy3yEeelZcmsvRvW49HQgonXoF+7FukdGMPeTQ/ycms9jnxxmf0YRT9/SE72DtBIK0RZI4SREG1BcUcM/N6Xwwa4MrAo4O+qYdUNnJnZ1JSwkwN7hiWbwddPz3n1npiz4YFcmR0+VsHr6AMK8pcVQiNZORuQJ0YpZrAof7cnkxuU/8d+datE0vk8wmx8fyZ+v7ywTK7ZR9VMWvHvvIDydHTl8qoRbVm5nS3KuvUMTQvwG+dQVopU6mFnEba//wsK1RyksryEmwI01fxjC6rsHEOLlbO/wRAu4oXsA6x8ZQZ8wT4orarn/vb388/tkLNZWf7GzEB2WdNUJ0crkl1Xz0sYkPt13CgB3vQNzb+rKjKGROOrku057E+7jwmcPDeW59Ql8sCuT1348zoHMYl69qx++buevoCCEsC8pnIRoJeosVv5vVwb/3JSCuaoOgNsHhDF/XDcC3GW5jvZM76Dj75N6Exfpw8K1R9l+PJ/fvfYzq+8eQFyUj73DE0KcRQonIVqBXWkFPPN1PElGdeXx2BAPnr01loGRctLsSCb1DyU2xIOHPtjPibxypr61iwU3d+cP13aSyUyFaCWkcBLCjowlVbzwbSJfH84GwMvFkb+M7cZdgyLQaeVE2RHFBLrz9ewRPPnFUb46lM3z3yay52QhL9/ZF0/njj3buBCtgRROQthBTZ2V/2xPZ+WPqVTUWNBoYNrgCP4yphverk72Dk/YmavegRVT+zEoyodn1yWwKcHELSt/5vW7B9I7zNPe4QnRoUnhJMRV9lNKHku+jictvxyAARFePHtrL3qFyglRnFE/23jfMC/+vGY/WYWV3P7GDp6+pQe/vyZSuu6EsBMpnIS4SrIKK3hufQLfJ5gA8HPTs3Bcd27rH4pWuuXERfQO82T97Gt54vPDbEow8fRX8exOL2TZ7X1w08tHuBBXm7zrhLCxqloLb/50gje2nqC6zopOq2Hm0Cjm3hSDh0HGrIjf5uniyFv3DOQ/29NZtiGJ9UdySMguZfX0AfQI7pgr1AthL1I4CWEjiqKwKcHEs+sTOFVUCcDQaF+W3BpL10B3O0cn2hqNRsMfro2mf4Q3s9ccaFgoeMnEWKYOCpeuOyGuEimchLCBE3llLFmXwLaUPACCPQ08Nb4H43sHywlOXJGBkd588+i1zPv0EFuT81iw9ii70gp4/rbeuErXnRA2J+8yIVpQeXUdK388zn+2p1FrUXDSafnjdZ2YdUMXXJzk7SZaho+rE+/MHMS/tqXx8vfJfHkomyOnS1h9t3TdCWFr8kkuRAtQFIV1R3J44ZtEjKVVAFzfzZ/FE2Lp5Odq5+hEe6TVanj4+s4MivJm9pqDpOWpXXfPTIzlLum6E8JmpHAS4golGUtZ/OuVTgARPi48fUtPRvcIkJOXsLm4KB++nXOm627h2qPsPFHAC5N7y1V3QtiAvKuEuEwllbWs+CGF/+7MwGJVMDhqmXV9F/54XTQGR529wxMdSH3X3Vs/p/GP75L5+nA2R0+XsOru/sSGyPxgQrQkKZyEaCarVeHzA6d4aWMS+WU1AIzrFcRT43sQ5u1i5+hER6XVanhopNp198iag6Tnl3Pb6zt4+pae/H5IhLR+CtFCpHASohmOnCpm0VfxHMoqBqCzvyvPTIzl2hh/+wYmxK8GRvrwzaPX8sRnh9mclMvTXx5jx/F8lt3eR9a6E6IFSOEkRBMUltfwj++S+XhvJooCrk465oyO4d5hnXBy0No7PCEa8XZ14t8z4/jP9nRe3JjEhmPGX7vuBtAv3Mve4QnRpknhJMQlWKwKa3Zn8PL3KZRU1gJwa78QnvxdDwI9DHaOToiLq58wc1CUD7M/OkBWYSV3vLGDv97cjT+MiJZlfoS4TFI4CXER+04WsuireBJySgHoHuTOs7f2YnAnHztHJkTT9Q334ptHr2Xh2qN8cySHF75NYseJApbf2RdfN729wxOizZHCSYhz5JZWsWxDEmsPngbAw+DAE2O7cffgCBx00i0n2h4PgyOrpvVnWGdfnl2XwNbkPMa9+jMr7urHsM5+9g5PiDZFCichflVrsfL+jpOs+CGVsuo6NBqYMjCcv97cTb6ZizZPo9EwfUgkAyPVCTOP55Yx/d+7mX1DF+aMipEvBUI0kbxThAB+OZ7PuFd/5u/fJFJWXUffME+++PNwXryjjxRNol3pHuTB17OHMzUuHEWBlT8e5663dnG6uNLeoYk27vrrr2fu3LkX/X1UVBQrVqy4avHYirQ4iQ7tdHElz3+TwLdHjYA6keD8m7tx58BwGTwr2i0XJwdevKMPw7r48tQXx9iXUcS4Fdt46Y4+3Nwr2N7hCdGqSeEkOqSqWgtvb0tj9dbjVNVa0WpgxtAoHhvdFU8XmetGdAy39gulX7gXj350kMOnSnjogwNMHxLB07f0lNnvhbgI6aoTHc7mRBNjXtnG8k0pVNVaGdxJnTDwmYmxUjTZUFVdFWlFaVTVVbXcQS0WqK6GmpqWO2YHE+nrymcPDeNPI6MB+HB3JhNXbSfZaLZzZKItqqurY/bs2Xh6euLn58fTTz+Noijn7Xfy5Ek0Gg2HDh1quK24uBiNRsPWrVsbbjt27Bjjxo3Dzc2NwMBA7rnnHvLz86/CM7k4aXESHcbJ/HKeXZ/Aj0m5AAR66Hnydz2Y2DdElqOwsc1pm5n86WRKq0rxcXTn89s+5obwa6GurmmbxQK1tY1/rquDsz+QtVowGNRNrz/z/3M3h6Z97FXVVWEsM+Lh44GLU/teSsfJQcvCcT0Y3tmPeZ8eJsVUxsRV2/mbLNcimun999/ngQceYM+ePezbt48HH3yQiIgI/vjHPzb7WMXFxdx444384Q9/4JVXXqGyspL58+czZcoUfvzxRxtE3zRSOIl2r6Kmjte3nOCtbWnUWKw46jTcP6ITj9wYI6vH24LVCpWVYDZDeTnVxQW8+PZEhpZX4GgBDWbeTLmD4bf9H046p5Z93IoKdbsUB4dLF1YGA5uzf+GOz6cQo48htTqVz6d8zqjoUS0Xayt1XVd/NsxRl2v5KSWPp788xs8pebx4ex+8XVvwbyXarfDwcF555RU0Gg3dunXj6NGjvPLKK5dVOK1atYr+/fvzwgsvNNz2zjvvEB4eTkpKCl27dm3J0JtMzhqi3VIUhW+PGvn7NwnklKjdQ9fG+LF4QixdAtzsHF07UFMDZWVQXq7+W7+VlzdqCSoqM6IvPVPMKEBZXSUFdWaC3cPVQuZCm04Hjo6Nf67/v6PjmZ91OvXxqquhquriW3V141ar8vILPy1LDW99cQ/DLNWEeZZCXSl/XX0rvzx6GIOXH7i5qY/ZTvm763n33kG884u6XMv3CSaOnPqZf07tK3M+id90zTXXNGqhHDp0KMuXL8disTT7WIcPH2bLli24uZ3/eX3ixAkpnIRoSakmM4u/jmfHiQIAQr2cWTShJ2N6Bkq3Q3PUt+JcqEC61LginQ5cXcHdHW99JKlH3DBSRoUDWLTgavDAY8Jd1OkMWK1q3VP/r1YLGs2FN+3FRmVqNODsrG6XYrFcuriqqqIgP5eK2koc0OBabSW4QsFqLqd4x48EuQWpx3F2VgsoV1f13/rNYFBjaeO0WnW5lmuifXn044Ok5ZUz/d+7eXhkZx67qSuOMueTuELaX9/MZ49/qq2tbbRPWVkZEyZM4MUXXzzv/sHB9rv6Uwon0a6Yq2p59YdU3ttxkjqrgt5By0MjO/Pw9Z3lKqHfUlUFxcXqZjY3FEtWi0Jt7ZnGmrP/X6NzpsrBjSqdK9WObg1bjcVAXaWGOqO6360+u3ht1xvU1lZjcHDhgYEP8eH7l7fWn1bbuPHp3Mao+gYpvR6cnM79V4eTkyt6vSsGD3W/c3nXVbHj+GNYysupNriSVqDBHxe8QzpDVa1aMFZWqlteXuM7n1UwnldUtcFWql6hnqx/ZARLvk7gk31ZvL71BL+cKOC1u/oR6etq7/BEK7R79+5GP+/atYuYmBh057z+/f39AcjJyaF///4AjQaKAwwYMID//e9/REVF4dDEsYlXQ+uJRIgroCgKXxw8zdINSeSZqwG4qWcgi27pSbhP+x7Ye1lqaqjMKaYyp5ia3GJq8oqpNVdTU3PmIrXqGqiphhqLjjq9K7V6tzObwY06vRuKVgdW1K324g/X2TOWl0e/QnFVMV4GLxx1l3/1otWqbrWXeLymcnA401BVv7m4GHhp4Pc89uNDmAgg1zeQ16f/H/rON6p3ulQXpcUCpaXqdq6zW6k8PSEgQG2hauXq53y6rqs/C9ce4XBWMb979WeW3NqL2weESguuaCQzM5N58+bxpz/9iQMHDrBy5UqWL19+3n7Ozs5cc801LFu2jE6dOpGbm8vf/va3RvvMmjWLt99+m2nTpvHXv/4VHx8fjh8/zscff8y///3v84qxq0UKJ9HmxWeXsPirePZlFAHQyc+VxRN6cn23ADtHZj8Wy5lGo7KiWqpMJVSb1CKpLr+Y2tJKrNZz7qTRUGtwp9rZi1pnD2q91CLJ4qh2P9W32ric1YJT35rj5KS23pw9JOn8zRGt1r9Rt9vZ3XJnd8PVd9tdaLNYzlxUd+6Fd/X/r61VC8D6IrC+IGwoCqvP7G82q1tj1/BC1G5MhbkE+gRwcouej/bUNx454erqg5ubD+7u4Bmq3q7l10HxZxdTZ3drXqiVyssLgoLUzd3dNi+GFjK+TzD9Irx47OND7DlZyBOfHWZrci7P39YbT2eZxkOoZsyYQWVlJYMHD0an0zFnzhwefPDBC+77zjvv8MADDzBw4EC6devGSy+9xJgxYxp+HxISwi+//ML8+fMZM2YM1dXVREZGcvPNNzd09dmDRrnQBAutTGlpKZ6enpSUlODh4dFix7VareTm5hIQEGDXP0J7Zev8FlfUsPz7FD7cnYFVARcnHY/cGMP9I6LQO7S9bpHmqqmxcuJEHnq9P2azltJSKCm0UGUqoTavGKfKYvQVxThUX3gQdK3BDa23FzofTxz9vXDw9cTZTYeLy/mtMHp9uxi600ht7ZlaprJSHcp19s9lZVZyckrR6TzQaC79+tVo1LrH0xM8PBr/6+4O2rpzWqkKCqCoqPFBXFzOFFE+Pq024RarwutbjrNicyoWq0KolzOvTO3H4E4+zTqOfP7alq3ya6vzcVsiLU6izbFYFT7Zm8U/vkuiqELtr5nQN4Qnf9edYM/fGBzcBlVXq+fY+q24WP3XXGKlJr8KX91JDFWlOFUU41hdhtuv34Xqu6EMHuDk5YJTgBf6AE8MQV64hnji6uV48cHWHUB9C9nFPvutVsjNrcLPz4OqqsY9cvX/N5vVXrm6uov30Gm14OXlhLe3D97ePvj4gHdv8HCqQpNrAqMR8vPVyi0tTd0cHSEwUC2i/P2bPPfU1aDTanhkVAzDY/yY+/EhMgsruOutncy6oQuPjoqRgeOi3Ws970YhmuBAZhGLv4rn6OkSALoFuvPMxFiGdva1c2RXrq4OCgvVc+jZRVLDtERWK06VJRjK8nEty8e7LB9LbRm+vi64umpx8VaHzzh7G3AO9sIQ5KU2eXh5qX1p4rJotWfGd1+Ioqh/o9JSKCk5/9/6v2thYeP76XQGvLwi8faOxC+4jgBNHr61RhwLTWpz2KlT6qbVgp+fWkQFBraacVEDIrz55tERPPN1Av87cIqVPx5nW2o+r07tR5SfDBwX7ZcUTqJNyDNX8+LGJD7ffwoAd70Dj93UlRlDI3Fog99wq6rUAqmgQN3y89WTbKOOc0XBsaoU97J8fCz5+FCIu3Mdbn7gGgUuzlbKa8ErKgCtt7daIHl5tZoTa0eh0agFq6srnHuFtKKoLVSFhWeK4cJCtSCuqzvz9z+OAxAMBOPhrhCsLyRQMeJbZ8LToRyn3FzIVWe8b03jotwNjiyf0pfru/nz1BdH1YHjr/3M4gk9mRIXLgPHRbskhZNo1eosVv67M4NXNqVgrq4D4M6BYfz15u74u+vtHF3T1NSo57zcXHVccH7+RedexB0zwY75+JGPl6UAd99aXCPO6qlxdFRbH/z8sPr4UFNRoV6d1ZH73FoxjeZMa1VExJnbFUXt5isqalw8m81QatZQavYlGV8gFscqM351RkK0RvwcivEsLsajsBhtUpJardV36dlxXNSEviEMjPRm3qeH2JVWyPz/HWVLUh5LJ/eWGcdFuyOFk2i1dp4o4Jmv40k2qZc89Q71ZMmtsQyI8LZzZBdntaonwfoiKTdXbV24EE9P8HcpJ1CXj6+iFkoGTXXjnRwcwNe3oVjC3f3MybF+ckrR5mg06tgqDw+IjDxze3W1WkCdvZXgTg7u5BCDrrYK51Mm3MqMBOjy8XIvx8s7DW+vNPTuTmoRFRqqvlauchEV4uXMh3+4hrd/TmP598lsjDdyILOIl+/sy3Vd/a9qLELYkhROotXJKank+W8SWX8kBwAvF0f+MrYbdw2KQKdtXU3/1dXq2N76LT9fvcz9XB4easNQoEcl/pp8vC35OJbkq3129ftrUCdJ9PFRT3y+vmq3jHR3dBh6vVr3hIaeua2mRi3CTSbIzTVgMkVirI7EZKnDUJaHy0kjzqUm3PQ1+Phk4eOThXeIAefoEAgLUyv0q0Sn1fDQyM6M6OLHnI8PciKvnBnv7OG+4VHMv7m7TEIr2gUpnESrUV1n4T/b01m5+TiVtRa0Grh7SASP39St1TT3l5dDTs6ZQuncAb+gnvwCAtTN36OaAG0+hrJfBzTlnNNHp9WCt/eZFiUvL+l2E404OZ1fTBUXQ26uAyZTMCZTMKcKFPTlhZhKsnGNP432SBUuLmn4+KThHeGOd69QXLqG/faSNC1EnXH8WpZuSOS/OzN495eT/HI8nxVT+9MzpGNewi7aj8sqnFavXs0//vEPjEYjffv2ZeXKlQwePPiC+8bHx7No0SL2799PRkYGr7zyCnPnzr2SmEU7tDU5lyXrEkjPVwuLgZHeLJkYS6/Qq/dt+ULKyiA7W91yci40UWLjsbqB3jV41hWc6WfJLmu8s0aj3qG+RcnHp00uxSHsq/46gPo1TmtqNBiNvmRn+5JzOpby9Fxcik5Tnm3k1Ckz7EjCxSUJz2hffPuGEdgvGEcX205a6eyk49lbe3FDtwD+8vkRUkxl3Lp6O4+P6cYfr41G2lFFW9XswumTTz5h3rx5vPnmmwwZMoQVK1YwduxYkpOTCQg4f6bmiooKoqOjufPOO3nsscdaJGjRfmQWVPDs+gR+SDQB6srsC8d157b+9lnKobpaLZJOn1a3kpLGv9do1HonOPjXYsmvDueKXwulnHxIvsBEPp6eZ8Yp+fq2qjl5RPvg5KQOPlcHoGupqQnCaAwiJ7OWooQcqtNOgzmfimMF5BwrIP7jozhHBeLTJ4ygPgH4+mtt1iN8Q/cAvpt7LQvWHmVTgollG5L4MSmX5Xf0QeYbF21Rs2cOHzJkCIMGDWLVqlWAOjtpeHg4jzzyCAsWLLjkfaOiopg7d26zW5xk5vC26VL5rayx8MZPJ3jzpxPU1Flx0Gq4b3gUj46Kwd1w9T5O6+rULrf6Qik/v/HvNRp1/sHQULVYCvSz4GguPDOXQHHxOXMIoA7gru968/W98EqyLUBev7bVnvJbUwM5aZXkHTpNScJpagvOFPhWnSOWwBA8e4YS0suHiEiNTab9UhSFT/dlsWRdAhU1Ftz0DswbGcbMkd3ttuZYeyYzh9tOs7761tTUsH//fhYuXNhwm1arZfTo0ezcubPFgqqurqa6+szVRaW/TsdrtVqxnrfA1uWzWq0oitKixxRnXCi/iqLwfYKJv3+TxOniSgCGRvvyzIQexAS6N9zPlkpLITMTsrLU1qVzB3N7e58ZUxIcaMWpvEgtlNLz4WDx+fG5up4pkvz81EFOZ7PR85HXr221p/w6OEB4Vz3hXaOBaEpPlZJ78DTFx05RbKxCczqd8tPpJG51Zr9vGG5dQwnv6U5kZMtOFXXnwDAGR3nzxGdH2J9ZzLPfn2TP6Uqev60X3i6tYxxje2Gr1297eD9cqWYVTvn5+VgsFgIDAxvdHhgYSFJSUosFtXTpUpYsWXLe7Xl5eVRVVbXY41itVkpKSlAUpc1/o2yNzs3vycIqXtmaxe5MtRAOdHdkznXh3NDFC42mktzcSpvEUVcHJpOW7Gwdp0/rMJsb90m4uCgEB1sJDrYQGFCHa20J2sJCtAlFVOwopvKcykoxGLD6+Kibt3fjAbfn9u3ZkLx+batd59cJPIb44jHYh4iCQorjczEn51KYW0FteiHV6UeI/8mDXZ6hOEYGENzJkbAwK76+1ivu0nMGXp0UzX/35vCfXTlsjDexN72Ap26KYlgn+45pbE9s9fo1X2igZwfTKgdbLFy4kHnz5jX8XFpaSnh4OP7+/i3eVafRaPD3929/H4ytQH1+nT28eX1rGu/8cpI6q4KTTsOD10Xz0MhoXJxs8xIsL4eMDLVlKTtbLZ7qeXqq45PCw9XNx7VavdbbaISkgsY7u7mpLUhnd725to7lJOT1a1sdJr+BgQT07KE2vZpMlKecJi/eRK6xluLik1iPZVCR7scB30gICqJTtIboaPU9dCVF1F/H+zM00pO/b87iRF458746zrTB4Tz1u+42+1zoSGz1+jXIygTNK5z8/PzQ6XSYTKZGt5tMJoKCglosKL1ej/7c7g7UbsGW/gDTaDQ2Oa74tVsuuYjVv8STa1a7Xm/sHsCiW3raZC2rwkK1WDp5Up335mzu7mcKpdBQcKop+7VQMp6/Sv25hZKdl7W4FHn92laHyq9WC2FhuIeF4T6ihujsbKrTTlOQWkhubgH52QVU5xjIzogg5Ugkek8DnTpxRUVUjyBX1s0ezsvfp/LOL+l8tCeLnScKWD6lLwMjfVr+OXYwtnj9doj3wm9oVuHk5OTEwIED2bx5M5MmTQLUqnbz5s3Mnj3bFvGJNioxp5RFXx1j70m1KIn0dWHRLT0Z1SPwN+7ZdIqiNhSdPKlu565MHxAAUVHqlUY+3opaIBmNsN14/pon9XMKBASos1XKpJOiI3Nygqgo9FFRhAwpJyQrC0t6JoU5VRiNKZhSUzG7BHLCFEX8MT9cXDVERalFVHBw894+Bkcdiyb0ZFSPAJ747DAnCyq4882dPDSyM3NHd8XJQU7UonVpdnvovHnzmDlzJnFxcQwePJgVK1ZQXl7OfffdB8CMGTMIDQ1l6dKlgDqgPCEhoeH/p0+f5tChQ7i5udGlS5cWfCqiNSipqOWfm5L5v10ZWBXQO2iYfWMMf7w2ukVmDbZa1a63EyfU1qWzh7zpdGprUn2x5KK3qE1PmUbYa1IvLarXSlecF6LVcXWF7t3Rde2Kf04O/hkZxOYVUFBgxGg0ctrkSpFnJEml4SQkOOHiAl26QEyM2mDbVMO7+LFx7nUsWRfP2gOneX3rCbYk5/HK1L50D+qYV2+J1qnZhdPUqVPJy8tj0aJFGI1G+vXrx8aNGxsGjGdmZjZqysvOzqZ///4NP7/88su8/PLLjBw5kq1bt175MxCtgtWq8Pn+U7y4MYmCcrVA+V2vIB4c7E+fLmFX1Lx7drF08qQ611I9vV4tkiIj1W44R+uv45WOGdWi6ewrQBwdzyyI6u8v8ykJ0RxabcPlplqzGf+MDPyzsoitKaegIAFjbhIna0IocI/iSIU3R46o87vGxKiFVFOGBno6O/LPKf0Y0zOQJ784RmJOKRNX/sJjN3XlweuiW92SS6JjavY8TvYg8zi1boeziln0dTyHs4oB6BLgxpKJsQyN9rns/NYXS2lpkJ7euFhydoZOndQtOBi0FWVn1kA5d7ySi8uZViUfn3a1nIm8fm1L8tsEdXXqBGi/9pVbLOrMHVklHhyvi8LsEYqiU7+ghISoRVSnTmpP4G/lN89czcK1Rxsmxx0Q4cXyKf3oZIPxke2RzONkO/KVW1y2grJq/vFdMp/sy0JRwE3vwNzRMcwcFoWjTtvs+T4URV3W5PjxixdL0dEQHKSgKf51vFLyJcYrBQaq45WEELbh4KA290ZGQlERupMnCXTMJjCwlL61RzDmJ3C8KoyTRJGd7U52Nvzyi/pe7tr10qsN+bvreXvGQD7ff4pn1yVwILOYca9uY+G4HtxzTSRaaX0SdiKFk2i2OouVNXsyefm7ZEqr1Ev3J/cPZcG47gR4NH+sUGEhpKaqBdPZNZDBoBZK0dEQ5G9BW5CnFktHZbySEK2Ot7e6xcZCVhaOGRmEO5YTzkkqKk9yqtyH5OoocmqCSU3VkpwMGo2BQYOge3e1cfhcGo2GO+PCGdbFj798dpgdJwpY/HU838UbeemOPoR5X+BOQtiYdNVJU3yz7EkvZNFXx0gyqpOg9Qz24NlbY4mLOv/S4Uvlt6xMLZSOH1cLp3pOTmqh1LkzBPtUo837dX6lC41XCgg4cyVcBxyvJK9f25L8XiFFUfvtTp5Uxx3+eqoprtSTWh3BsdIw8issuLu7o9NpiYyEbt3UsYoXSrfVqvB/uzJYuiGRqlorbnoHnr6lB1Piwu2yrmVrJ111ttPxzjbisphKq1j6bSJfHsoG1EGcT4zpyt1DIps8YLOmRh2zlJqqdsnV02rVAd4xMRDhU4YuzwjpRjjQccYrCdHu1C/06O+vXv7664y0XlQxyDmVfq7JHMszkOPUh1M1QZw8qeHkSfVt3r079OjReEC5Vqth5rAoruvqzxOfHWZ/RhHz/3eUjceMLLu9D4GX0dotxOWQFif5RnlJNXVW3tuRzqs/pFJeY0GjgbsGRfCXsd3wcb302lJWqxWTKReLJYDUVC3p6Y0n5Q4OhpguCp28itAX/Tq4W8YrNZm8fm1L8msDVqva+pSRgdVkoqSkBE9PT8qtrpyoi+RYaQQVFnXyY41GnVokNlYdWH42i1XhP9vTePn7FGrqrHgYHHhmYiy39Q+V1qdfSYuT7UiLk7ion1PzeObreE7kqcVMv3Avnr01lj5hXr95X7MZkpJg3z4DGs2ZxiEvL+ja2UKMVx6uZiNkmuD4BcYr1U8bIOOVhGg/tFr1G1NwMJjNWA4cgPJy3C2V9HNIoo8hhdPWYOLLIsks9yU9Xb1QxMtLLaBiYtTufJ1Ww4PXdeaGbgE8/tlhjpwqYd6nh/n2qJEXJvciwF0+N4TtSIuTfKM8z6miCv6+PpGN8UYAfF2dWDCuO7cPCLvklSx1depwhuRk9Qplq9WK2WzG19edrpG1dPc24Vcn45Vairx+bUvya1sN+fX1RWs0qh8excUNvy9V3EmuiuRYcRi1OALqR0PXrmoR5e2t7ldnsfKvbWms+CGFWouCl4sjSybGMrFvSIdufZIWJ9uRM5RoUFVr4a1taby+9ThVtVZ0Wg0zhkYyd3RXPJ0dL3q/wkJISFAHep99sVu4dxkhvkn08qvGsawEKs66k4xXEkKAOidB/UKSJSVqAXX6NB4WM4Ocj9FPn0hGXShHzVHk1XiSkKB+3oSFQZ8+EBamZdYNXbixu7pkS3x2KXM+PsSGo0aem9QLf/fz1z0V4kpI4SRQFIXNibk8uz6BzEK1uhnSyYclt8ZedKmDujp1oHdiojpk4dcD4aMpooe3kU7ORgwWMyUlJehKPdXCyMvrTBdcB/2mIoS4BE9P6NsXevaEU6cgIwNHs5kuTpl08c0k3+JNQnkkKWUhnDql49QpteWpTx/o2sWDL2cN5/UtJ1j5Yyob443sTi9gya29mNAnuEO3PomWJYVTB5eeX86z6+LZkpwHQJCHgafG9+CWi3zQFBer3/ZSUtTWJY3Vgmt5Hp1djXRxN+HrXqMu8KmAVavF6uurXh4TEiLjlYQQTePoeGZ5gIIC9Yq8nBz8KOI6jyLinONJqYrgaGkkRUWu/PQT7NkDsbFa/jQihpt6BvLEZ4dJyCnl0Y8O8u2RHGl9Ei1GCqcOqqKmjlU/HuffP6dTY7HiqNPwh2ujmX1DF1z1jV8WFos6QDMxUZ1GQFtbjbPZRHCtkS6eeYRFWtHXfx6dPV7Jz4/awkL1Z+mKE0JcDl9fdauuhsxMyMjAhUr6OZ4g1nCCjAp/jpRGkV8RyL59Gg4ehJgYD/57z3A+OHCcVT8eb2h9ekbGPokWIIVTB6MoCt8czeH5bxLJKakC4Lqu/iye0JPO/m6N9i0vV1uXEhOhrrgMl1IjQaVGwt2KCAtTL37TaFDXQwkKUrezxys1c8kVIYS4KL3+zIrBublw8iSOubl08cwj2j0PY7FBvRqvNoKkJANJSVp6RXfl/buDeX7zIRJy1LFP64/k8PykXpe1yoEQIIVTh5JiMrP4q3h2phUAEObtzKJbenJTz8BG38CMRjh2VCE7vghDsRGfUiNumnLCwiCs2689bp6eZ4olGa8khLhaNBp1rGRgIFRUQEYG2sxMQnyqCPFJpqg4haTiIJKsXUlL84A0dx7uPJzDISd5/1ASmxJM7E4rYPGEWCYPkHmfRPNJ4dQBlFbVsmJTKu/vPInFqqB30PLw9Z15aGRnDI46quqqyCrOpioniMw9pVSdNOJcaiKgrgYfH4joCQGBWrT+vmeKJRmvJISwNxcXdQxlt27qOIKTJ/GmkKFeOfQy55BUEkx8XTdyst0JIJrHugbxv5PHOFGZx+OfHWb9kWxemNybYE9nez8T0YZI4dSOWa0Kaw+eZtmGRPLL1HkCxsYG8rfxPQn3URfH/Obg9zz+ymI8Mr0JrXFgfOebifAKJyQEIjo74tFF5lcSQrRyWi2Ehqqb2QypqbifPs0g9xxiK3JIModypLob4ModgXHsN5nYbErmx6Q8xvxzG0+O78Fdg2TNO9E0ciZsp46dLmHRV8c4kFkMQLSfK4snxjKyqz+gDhHYf6iGh1/9lL55noCFOodyvjS/zppH3scjOlLmVxJCtD3u7jBggDoeKjkZl5wcBricpmdNNikV4Rwqj2FwcDCRrt6sSzrJaYdsFvzvKOuPZLNscp+GL5VCXIwUTu1MUXkN//g+mY/2ZKIo4OKk49FRMdw/vBOOOi0nT8KRI+o4przyEk5pNIR7mskLycAYfBqzM+THeOPh7WfvpyKEEJfP3R3i4tRJNZOTMZhM9HHKpIf7KVKrwtmv6cr9cd3YccKXH46fYmtJETed3Mb8cd2YMTSqyYuXi45HCqd2wmJV+GhPJi9/n0xxRS0At/YLYeG4Hvi5GkhNVQumkhJ1f60WBvXxxLVwEzsdMlFQ0KDBQ+9OiHvIJR5JCCHaEE9PGDwYioogORnHvDx6umYQY8giuToK55gudA/uydoDp8gwFfN0QTrrj+Tw4u296RLgbu/oRSskhVM7sD+jkEVfxROfXQpA9yB3npkYS78QXxIS4PtjUKXOPICTkzopb69e4OLixJed/sPkTydTWl2Ku96dtVPWYnCQgd9CiHbG2xuuuUadUDM5GceCAnq5pNHNkEGSVyeCXaP5Od2LjceMbDNWcVP8Pp64PZwHr4vGUSdDFsQZUji1YbnmKl7ckMz/DpwCwN3gwOM3dWViz0gS4rWs2aoujQLg5ga9e0P37uoclfVGRY/C9ISJbHM2Ie4hUjQJIdo3X18YNkxdbDw5GceiIno7H6eb/iRxPp3oGxLFJ/tzST7uyJJVxXz+8x5eu78HvcM87R25aCWkcGqDai1W/rszgxWbUjBXq5XRlLgwHojrTtZxPZ9/dmZfPz916adOnS4+ztvgYCDaO/oqRC6EEK2Ev7+6mUyQnIxTSQm9Dal0izrJyOBo3jkSxBeH8ziyw8KY+BT+MNmTpyarU7iIjk0KpzZmx4l8nvk6nhRTGQC9Qz15dGgv6vK8+On7M/tFRKgLX4bIcCUhhLi4+sk0jUZISsLJbKafIZmX4pyYFB3OC9vdOXgaXn+3iq9/PMLyhyMZ3c/H3lELO5LCqY3IKank798k8s2RHAC8XRz5Q/9YwqwhpB9Qr/7QaKBzZ+jXT51JQAghRBMFBakFVHY2pKRgKCvjRr8TDLlFzwcp/ry0w4lTGTB14SnGjSjkHw9FEuzr+NvHFe2OFE6tXHWdhX//nM6qH49TWWtBA0yI7sJgj2gqchwxoXbBde2qFkyy+okQQlwmjUadRDMkBE6dgpQUXCsq+FPPU0wMd+D5ne58nOLGhp8r+GV/Ko/f5c9Dk/1lbuAORv7crdiWpFyWrIvnZEEFigI9XYMZE9gdV1yoKFUn8u7RQ+2Sc3W1d7RCCNFOaDQQHq4WUb8WUMFUsmpMEb/vVsCTP7tzuNiXxe/k8L/NZv7+YCjDBuiRicc7BimcWqHMggqeXZ/AD4kmFAU8qr0ZE9Sdrt7eaDQanJwgNla9Sk6WjBNCCBvRatUBo2FhkJEBqalcE1nNxtBS3tubxysH/DmSAVMWH+f2Ef789ff+hIVJ9dTeSeHUilTWWHhj63He3JZGda0VpdiNYV5dGBYThMFRh8GgFkuxsep8TEIIIa4CrVa9NDk8HNLScDpxggeH6hjbNY8Xf8ziW2MXPtxqYftRM49MDGbyzS54yuwF7ZYUTq2Aoih8F2/kufWJnCqqpK7IhU6aMG6OCSfAw4DBoI5f6tlT1tkVQgi7cXBQB5RGRkJqKpHaDFbe7sytRxNZuduRQ7ndmf9+BRt2+/PwJH+GDdGh19s7aNHS5DRsZ8dzy1iyLp5tKfnUFbvgZo5kbEwYsSGeODtr6NtXbWGSgkkIIVoJvV5dfiE6Gl1SEmO1GuI6V/Putl2sSwtg27GuHMkqYcqeEKaNd6d7d2T8Uzsip2M7Kauu47XNqfzn53SqCp2x5oUwIiKYkX0DcHfVNhRMjnK1qxBCtE4uLjBgAHTujG9iIo+7OnF9RhHv/PQj+4s68+b35exODeD31wcy5kZHAgPtHbBoCVI4XWWKovDVoWye/yaR7FNaaoyBdPP25ZYRwQT76unTR8YwCSFEm+LpCddcgyYvjzivRHoEe/D5/lNsPJhGUkpPns6JYGdCKHfe6MWQIRpcXOwdsLgSUjhdRQnZpSz++hg7j1RSk+ONl9aVuwaE0DvCgz591JZfKZiEEKKN8vcHPz9cc3KY6ePJ0M5G3vv5CMlZJ/jp5x4cyIjmjvhQxo7UExt78WWwROsmhdNVUFJRyz83JfPe5hwqs73QVXowqnsAN/TwY0A/LX36SMEkhBDtgkajTqAZFETX6EyWhPqwcX8GX+3dhelkOv/J7s7+9G5MHOTHyOu0sixWGySFkw1ZrQqf7svihS9PYDrhQl1JIL3DPLnlumCGD3Kif3+Zh0kIIdolrRaionAMC2NC5zQGdYnng+3H8U35mZxd6fwzrRdH07px01BXhg6Vc0FbIoWTjRzKKuapTxPYv19DbaEvAe4Gbr02mHEj3Bk4ENzc7B2hEEIIm/t1CoOgyEgej01h55YDfLIjg0KjkZ3rUzl6oh+DDnty62hv+sTK7ONtgRROLSy/rJoXvk7mow1mavLdMeh0jOkTyF03+DD0Gi3e3vaOUAghxFWn16Pp3Zth0dH0HniMtet3s/VoMtUJRjYkB7DiByNzJ9zAI1P6yXmilZPCqYXUWay8tz2DZWtyKM5yRbG6MyDCm5mjAxlzvRMBAfaOUAghhN25uuI+fAhTu0fx4ZM3EGQYSdfiCizmWP75lQnMZdx8nRsDBsj8fa2V/FlawM4TBfz1P2kkHnVEqXUjxMuZGTcEMW28O2Fh9o5OCCFEa5OtLWdTSCJ+Hin0zr8Oo2dX9DmBrNqcxpGsACYkB3Dj9VrCw+0dqTiXFE5XwFhSxZMfHGfdpmqsVXpcnHRMHB7AnLv8iOmikb5qIYQQFxTiHoKH3oMCzGxx24KDNQF/t1loC4bzU7qFw6eKOZIewi3Xesjg8VZGCqfLUFNnZeWGDF79qIDyQic0GkeGxXgz//dBDI1zRKezd4RCCCFaM4ODgbVT1jL508mUVpfi4lzJf+8cSl1lDxZ9kUhWSgXv7ahh70lP7kgO5pYxTkRH2ztqAVI4Ndv3h/NY8K9TZKTpACcifV2YNzWIO8a4yTcCIYQQTTYqehSmJ0xkm7MJcQ/B4KCeREbE+PPqDym8/X02iRm1LF1vZu/xQKaN8uX6kVqZedzOpHBqovTcCh5/8yTbdtWiWHW46R2YMcafx6f74eUlfXJCCCGaz+BgINq7cVOSm96Bp8b3ZPKAMJ5ae4ydeyr5Nt7Kgcwi7ogP4e4JbnTrZqeAhRROv6WyxsJzazJ594tSaqo1aDVabhroxbN/DCImSlbgFUIIYRs9gj34/OGhfDY4i7//7zimZE9W/ZDGjhRv7h8bxC1jHHF3t3eUHY8UThehKAqf/ZzH4n8byc0F0NAtzJln/xjM6CEye6UQQgjb02o1TB0UwZieQby4IYn/flvMgSxIfK+UzQcCmTPNl969pNfjapLC6QLiM8qYtzqLfUdqAfByc2DOFD/+PNkfBwd5gQohhLi6vF2dWHZHH6YMLmLBR4kc2uPIF/uz2XOiiD+OC+b+O9xwdbV3lB3DZa3NvHr1aqKiojAYDAwZMoQ9e/Zccv/PPvuM7t27YzAY6N27N99+++1lBWtrpRV1zFmdzo2z0th3pBYHrZY7bvRi19tdeXRKgBRNQggh7GpAhDffPnENL83zxyfazOmSSpZ8nMaU+VnsPVxj7/A6hGYXTp988gnz5s1j8eLFHDhwgL59+zJ27Fhy1f6s8+zYsYNp06bxwAMPcPDgQSZNmsSkSZM4duzYFQffUmrqrLyyNot+9ybywTozdXXQN8bA+uWd+NdfI/D3loY5IYQQrYODTsu9w6PY8WIcd03RoHWuYdfxIiY/ncqC10yUlSv2DrFd0yiK0qwMDxkyhEGDBrFq1SoArFYr4eHhPPLIIyxYsOC8/adOnUp5eTnr169vuO2aa66hX79+vPnmm016zNLSUjw9PSkpKcHDw6M54V5SXZ2Ftzam8vraanKy1dYkfy8HFswIYMbNvmi10sJ0JaxWK7m5uQQEBKDVXlbjprgEya9tSX5tS/LbcnanFfLY6+kkxzuCAhH+Bp77UwBxXapaPL+2Oh+3Jc3KZk1NDfv372f06NFnDqDVMnr0aHbu3HnB++zcubPR/gBjx4696P5Xyy/JhYx44ihPr6ohJ1uDu8GBR+70Y/+73bn3d35SNAkhhGgThkT7sO3F/jzziCeu7lYy86q49/lM/vxaETmF0n3X0prVB5Wfn4/FYiEwMLDR7YGBgSQlJV3wPkaj8YL7G43Giz5OdXU11dXVDT+XlpYC6jcUq9XanJAvKiHJSmqSFr2DlluHe/L0A4EE+Tk0PI64clarFUVRJJ82Ivm1LcmvbUl+W5ZWA7NuDuf2awL4y5uZbNxWzU8Haln2QQ6vPhrZYo8jf69WelXd0qVLWbJkyXm35+XlUVVV1SKP8bs4hQMj3PhdXA0D++jQWgu5yDAtcZmsVislJSUoiiJN8TYg+bUtya9tSX5tQwssv9+TCXHlrPrCzJ/HO1x0DPLlMJvNLXastqpZhZOfnx86nQ6TydTodpPJRFBQ0AXvExQU1Kz9ARYuXMi8efMafi4tLSU8PBx/f/8W7VNducBKXl4e/v7+8sa1AavVikajkfzaiOTXtiS/tiX5ta07brQysnfLn98MsrZY8wonJycnBg4cyObNm5k0aRKgvvg3b97M7NmzL3ifoUOHsnnzZubOndtw26ZNmxg6dOhFH0ev16PX68+7XavVtvgbTKPR2OS4QiX5tS3Jr21Jfm1L8mtbtsiv/K0uo6tu3rx5zJw5k7i4OAYPHsyKFSsoLy/nvvvuA2DGjBmEhoaydOlSAObMmcPIkSNZvnw548eP5+OPP2bfvn289dZbLftMhBBCCCFsrNmF09SpU8nLy2PRokUYjUb69evHxo0bGwaAZ2ZmNqpIhw0bxpo1a/jb3/7Gk08+SUxMDF9++SW9evVquWchhBBCCHEVNHseJ3uw1bwRMo+IbUl+bUvya1uSX9uS/NqWrfIr8zi10qvqzlVf29VPS9BSrFYrZrMZg8Egb1wbkPzaluTXtiS/tiX5tS1b5bf+PNwG2lxspk0UTvWXP4aHh9s5EiGEEEKYzWY8PT3tHYZdtImuOqvVSnZ2Nu7u7mg0LTejd/00B1lZWR22ydGWJL+2Jfm1LcmvbUl+bctW+VUUBbPZTEhISIdtKWwTLU5arZawsDCbHd/Dw0PeuDYk+bUtya9tSX5tS/JrW7bIb0dtaarXMctFIYQQQojLIIWTEEIIIUQTdejCSa/Xs3jx4gvOUi6unOTXtiS/tiX5tS3Jr21Jfm2nTQwOF0IIIYRoDTp0i5MQQgghRHNI4SSEEEII0URSOAkhhBBCNFGHLZxWr15NVFQUBoOBIUOGsGfPHnuH1CYtXbqUQYMG4e7uTkBAAJMmTSI5ObnRPlVVVcyaNQtfX1/c3Ny4/fbbMZlMdoq4bVu2bBkajYa5c+c23Cb5vTKnT5/m97//Pb6+vjg7O9O7d2/27dvX8HtFUVi0aBHBwcE4OzszevRoUlNT7Rhx22GxWHj66afp1KkTzs7OdO7cmeeee67Rch2S3+bZtm0bEyZMICQkBI1Gw5dfftno903JZ2FhIdOnT8fDwwMvLy8eeOABysrKruKzaNs6ZOH0ySefMG/ePBYvXsyBAwfo27cvY8eOJTc3196htTk//fQTs2bNYteuXWzatIna2lrGjBlDeXl5wz6PPfYY69at47PPPuOnn34iOzubyZMn2zHqtmnv3r3861//ok+fPo1ul/xevqKiIoYPH46joyMbNmwgISGB5cuX4+3t3bDPSy+9xGuvvcabb77J7t27cXV1ZezYsVRVVdkx8rbhxRdf5I033mDVqlUkJiby4osv8tJLL7Fy5cqGfSS/zVNeXk7fvn1ZvXr1BX/flHxOnz6d+Ph4Nm3axPr169m2bRsPPvjg1XoKbZ/SAQ0ePFiZNWtWw88Wi0UJCQlRli5daseo2ofc3FwFUH766SdFURSluLhYcXR0VD777LOGfRITExVA2blzp73CbHPMZrMSExOjbNq0SRk5cqQyZ84cRVEkv1dq/vz5yogRIy76e6vVqgQFBSn/+Mc/Gm4rLi5W9Hq98tFHH12NENu08ePHK/fff3+j2yZPnqxMnz5dURTJ75UClC+++KLh56bkMyEhQQGUvXv3NuyzYcMGRaPRKKdPn75qsbdlHa7Fqaamhv379zN69OiG27RaLaNHj2bnzp12jKx9KCkpAcDHxweA/fv3U1tb2yjf3bt3JyIiQvLdDLNmzWL8+PGN8giS3yv19ddfExcXx5133klAQAD9+/fn7bffbvh9eno6RqOxUX49PT0ZMmSI5LcJhg0bxubNm0lJSQHg8OHDbN++nXHjxgGS35bWlHzu3LkTLy8v4uLiGvYZPXo0Wq2W3bt3X/WY26I2sVZdS8rPz8disRAYGNjo9sDAQJKSkuwUVftgtVqZO3cuw4cPp1evXgAYjUacnJzw8vJqtG9gYCBGo9EOUbY9H3/8MQcOHGDv3r3n/U7ye2XS0tJ44403mDdvHk8++SR79+7l0UcfxcnJiZkzZzbk8EKfF5Lf37ZgwQJKS0vp3r07Op0Oi8XC888/z/Tp0wEkvy2sKfk0Go0EBAQ0+r2DgwM+Pj6S8ybqcIWTsJ1Zs2Zx7Ngxtm/fbu9Q2o2srCzmzJnDpk2bMBgM9g6n3bFarcTFxfHCCy8A0L9/f44dO8abb77JzJkz7Rxd2/fpp5/y4YcfsmbNGmJjYzl06BBz584lJCRE8ivarA7XVefn54dOpzvvqiOTyURQUJCdomr7Zs+ezfr169myZQthYWENtwcFBVFTU0NxcXGj/SXfTbN//35yc3MZMGAADg4OODg48NNPP/Haa6/h4OBAYGCg5PcKBAcH07Nnz0a39ejRg8zMTICGHMrnxeX5y1/+woIFC7jrrrvo3bs399xzD4899hhLly4FJL8trSn5DAoKOu9CqLq6OgoLCyXnTdThCicnJycGDhzI5s2bG26zWq1s3ryZoUOH2jGytklRFGbPns0XX3zBjz/+SKdOnRr9fuDAgTg6OjbKd3JyMpmZmZLvJhg1ahRHjx7l0KFDDVtcXBzTp09v+L/k9/INHz78vOkzUlJSiIyMBKBTp04EBQU1ym9paSm7d++W/DZBRUUFWm3j04xOp8NqtQKS35bWlHwOHTqU4uJi9u/f37DPjz/+iNVqZciQIVc95jbJ3qPT7eHjjz9W9Hq98t577ykJCQnKgw8+qHh5eSlGo9HeobU5Dz/8sOLp6als3bpVycnJadgqKioa9nnooYeUiIgI5ccff1T27dunDB06VBk6dKgdo27bzr6qTlEkv1diz549ioODg/L8888rqampyocffqi4uLgoH3zwQcM+y5YtU7y8vJSvvvpKOXLkiHLrrbcqnTp1UiorK+0Yedswc+ZMJTQ0VFm/fr2Snp6urF27VvHz81P++te/Nuwj+W0es9msHDx4UDl48KACKP/85z+VgwcPKhkZGYqiNC2fN998s9K/f39l9+7dyvbt25WYmBhl2rRp9npKbU6HLJwURVFWrlypREREKE5OTsrgwYOVXbt22TukNgm44Pbuu+827FNZWan8+c9/Vry9vRUXFxfltttuU3JycuwXdBt3buEk+b0y69atU3r16qXo9Xqle/fuyltvvdXo91arVXn66aeVwMBARa/XK6NGjVKSk5PtFG3bUlpaqsyZM0eJiIhQDAaDEh0drTz11FNKdXV1wz6S3+bZsmXLBT9zZ86cqShK0/JZUFCgTJs2TXFzc1M8PDyU++67TzGbzXZ4Nm2TRlHOmsJVCCGEEEJcVIcb4ySEEEIIcbmkcBJCCCGEaCIpnIQQQgghmkgKJyGEEEKIJpLCSQghhBCiiaRwEkIIIYRoIimchBBCCCGaSAonIYQQQogmksJJCAGARqPhyy+/bPL+W7duRaPRnLfAsBBCtGdSOAnRgdx7771MmjTpgr/Lyclh3LhxLfp4zzzzDP369WvRYwohhD052DsAIUTrEBQUZO8QhBCi1ZMWJyEEcH5X3Y4dO+jXrx8Gg4G4uDi+/PJLNBoNhw4danS//fv3ExcXh4uLC8OGDSM5ORmA9957jyVLlnD48GE0Gg0ajYb33nuv4bH+/e9/c9ttt+Hi4kJMTAxff/11o+MeO3aMcePG4ebmRmBgIPfccw/5+fkNv//888/p3bs3zs7O+Pr6Mnr0aMrLywG1G3Hw4MG4urri5eXF8OHDycjIaPmkCSE6HCmchBDnKS0tZcKECfTu3ZsDBw7w3HPPMX/+/Avu+9RTT7F8+XL27duHg4MD999/PwBTp07l8ccfJzY2lpycHHJycpg6dWrD/ZYsWcKUKVM4cuQIv/vd75g+fTqFhYUAFBcXc+ONN9K/f3/27dvHxo0bMZlMTJkyBVC7FadNm8b9999PYmIiW7duZfLkySiKQl1dHZMmTWLkyJEcOXKEnTt38uCDD6LRaGycNSFERyBddUKI86xZswaNRsPbb7+NwWCgZ8+enD59mj/+8Y/n7fv8888zcuRIABYsWMD48eOpqqrC2dkZNzc3HBwcLtgNeO+99zJt2jQAXnjhBV577TX27NnDzTffzKpVq+jfvz8vvPBCw/7vvPMO4eHhpKSkUFZWRl1dHZMnTyYyMhKA3r17A1BYWEhJSQm33HILnTt3BqBHjx4tmyAhRIclLU5CiPMkJyfTp08fDAZDw22DBw++4L59+vRp+H9wcDAAubm5v/kYZ9/P1dUVDw+PhvsdPnyYLVu24Obm1rB1794dgBMnTtC3b19GjRpF7969ufPOO3n77bcpKioCwMfHh3vvvZexY8cyYcIEXn31VXJycpqZASGEuDApnIQQV8TR0bHh//XdYVartVn3q79v/f3KysqYMGEChw4darSlpqZy3XXXodPp2LRpExs2bKBnz56sXLmSbt26kZ6eDsC7777Lzp07GTZsGJ988gldu3Zl165dLfWUhRAdmBROQojzdOvWjaNHj1JdXd1w2969e5t9HCcnJywWS7PvN2DAAOLj44mKiqJLly6NNldXV0AttIYPH86SJUs4ePAgTk5OfPHFFw3H6N+/PwsXLmTHjh306tWLNWvWNDsOIYQ4lxROQnQwJSUl57XkZGVlNdrn7rvvxmq18uCDD5KYmMh3333Hyy+/DNCsQdZRUVGkp6dz6NAh8vPzGxVilzJr1iwKCwuZNm0ae/fu5cSJE3z33Xfcd999WCwWdu/ezQsvvMC+ffvIzMxk7dq15OXl0aNHD9LT01m4cCE7d+4kIyOD77//ntTUVBnnJIRoETI4XIgOZuvWrfTv37/RbQ888ECjnz08PFi3bh0PP/ww/fr1o3fv3ixatIi777670bin33L77bezdu1abrjhBoqLi3n33Xe59957f/N+ISEh/PLLL8yfP58xY8ZQXV1NZGQkN998M1qtFg8PD7Zt28aKFSsoLS0lMjKS5cuXM27cOEwmE0lJSbz//vsUFBQQHBzMrFmz+NOf/tTkuIUQ4mI0iqIo9g5CCNH6ffjhh9x3332UlJTg7Oxs73CEEMIupMVJCHFB//3vf4mOjiY0NJTDhw8zf/58pkyZIkWTEKJDk8JJCHFBRqORRYsWYTQaCQ4O5s477+T555+3d1hCCGFX0lUnhBBCCNFEclWdEEIIIUQTSeEkhBBCCNFEUjgJIYQQQjSRFE5CCCGEEE0khZMQQgghRBNJ4SSEEEII0URSOAkhhBBCNJEUTkIIIYQQTSSFkxBCCCFEE/0/mxcGD4QfOSIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "indices = [0, 100]\n", + "values = [0, 0]\n", + "\n", + "accent_weights = {\n", + " \"red\": 3.5,\n", + " \"orange\": 4.0,\n", + " \"yellow\": 0.5,\n", + " \"green\": 0.75,\n", + " \"blue\": 1.0,\n", + "}\n", + "accent_offsets = {\n", + " \"red\": -5,\n", + " \"orange\": -2,\n", + " \"yellow\": 0,\n", + " \"green\": 0,\n", + " \"blue\": 0,\n", + "}\n", + "hue_bez_cmax_map = {}\n", + "for i, (hue_key, hue_val) in enumerate(accent_hue_map.items()):\n", + " cmax_idx = np.argmax(hue_cmax_map[hue_key])\n", + " cmax_idx += accent_offsets[hue_key]\n", + "\n", + " cmax_lightness = lightness_levels_n1[cmax_idx]\n", + " cmax_chroma = hue_cmax_map[hue_key][cmax_idx]\n", + "\n", + " P0 = np.array([indices[0], values[0]])\n", + " P1 = np.array([cmax_lightness, cmax_chroma])\n", + " P2 = np.array([indices[-1], values[-1]])\n", + " \n", + " t = np.linspace(0, 1, 400)[:, None]\n", + " B = quad_bezier_rational(P0, P1, P2, w=accent_weights[hue_key], t=t)\n", + " \n", + " hue_bez_cmax_map[hue_key] = B\n", + "\n", + "fig, axes = plt.subplots(len(accent_hue_map), 1, sharex=True, sharey=True, figsize=(6, 10))\n", + "for ax, hue_key in zip(axes, accent_hue_map):\n", + " ax.grid(True, alpha=0.3)\n", + " ax.text(1.01, 0.5, hue_key, transform=ax.transAxes, va='center')\n", + " \n", + " ax.plot(lightness_levels_n1, hue_cmax_map[hue_key])\n", + " ax.plot(hue_bez_cmax_map[hue_key][:,:,0], hue_bez_cmax_map[hue_key][:,:,1], c='b', alpha=0.4)\n", + " ax.plot(lightness_levels_n5, mb_chroma_pts[hue_key], c='r', alpha=0.3)\n", + "\n", + " max_idx = np.argmax(mb_chroma_pts[hue_key])\n", + " spline_indices = [0, max_idx-1, max_idx+1, -1]\n", + " \n", + " ax.scatter(\n", + " np.array(lightness_levels_n5)[spline_indices],\n", + " np.array(mb_chroma_pts[hue_key])[spline_indices],\n", + " s=8, c='g'\n", + " )\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "plt.suptitle(\"Max chroma at different lightness levels w/in sRGB gamut\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "ba6adb00-e648-4510-97e4-71882c5564e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "'badlands' breached max chroma at L0\n", + "'badlands' breached max chroma at L1\n", + "'badlands' breached max chroma at L2\n", + "'badlands' breached max chroma at L98\n", + "'badlands' breached max chroma at L99\n", + "'badlands' breached max chroma at L100\n", + "'chaparral' breached max chroma at L0\n", + "'chaparral' breached max chroma at L1\n", + "'chaparral' breached max chroma at L2\n", + "'chaparral' breached max chroma at L3\n", + "'chaparral' breached max chroma at L4\n", + "'chaparral' breached max chroma at L99\n", + "'chaparral' breached max chroma at L100\n", + "'savanna' breached max chroma at L0\n", + "'savanna' breached max chroma at L1\n", + "'savanna' breached max chroma at L2\n", + "'savanna' breached max chroma at L3\n", + "'savanna' breached max chroma at L4\n", + "'savanna' breached max chroma at L5\n", + "'savanna' breached max chroma at L100\n", + "'grassland' breached max chroma at L0\n", + "'grassland' breached max chroma at L1\n", + "'grassland' breached max chroma at L2\n", + "'grassland' breached max chroma at L3\n", + "'grassland' breached max chroma at L100\n", + "'tundra' breached max chroma at L0\n", + "'tundra' breached max chroma at L1\n", + "'tundra' breached max chroma at L2\n", + "'tundra' breached max chroma at L98\n", + "'tundra' breached max chroma at L99\n", + "'tundra' breached max chroma at L100\n", + "'red' breached max chroma at L85\n", + "'red' breached max chroma at L86\n", + "'red' breached max chroma at L87\n", + "'red' breached max chroma at L88\n", + "'red' breached max chroma at L89\n", + "'red' breached max chroma at L90\n", + "'red' breached max chroma at L91\n", + "'red' breached max chroma at L92\n", + "'red' breached max chroma at L93\n", + "'red' breached max chroma at L94\n", + "'red' breached max chroma at L95\n", + "'red' breached max chroma at L96\n", + "'red' breached max chroma at L97\n", + "'red' breached max chroma at L98\n", + "'red' breached max chroma at L99\n", + "'orange' breached max chroma at L96\n", + "'orange' breached max chroma at L97\n", + "'orange' breached max chroma at L98\n", + "'orange' breached max chroma at L99\n", + "'blue' breached max chroma at L91\n", + "'blue' breached max chroma at L92\n", + "'blue' breached max chroma at L93\n", + "'blue' breached max chroma at L94\n", + "'blue' breached max chroma at L95\n", + "'blue' breached max chroma at L96\n", + "'blue' breached max chroma at L97\n", + "'blue' breached max chroma at L98\n", + "'blue' breached max chroma at L99\n" + ] + } + ], + "source": [ + "hue_bez_cmax_map = {}\n", + "for i, (hue_key, hue_val) in enumerate(accent_hue_map.items()):\n", + " cmax_idx = np.argmax(hue_cmax_map[hue_key])\n", + " cmax_idx += accent_offsets[hue_key]\n", + "\n", + " cmax_lightness = lightness_levels_n1[cmax_idx]\n", + " cmax_chroma = hue_cmax_map[hue_key][cmax_idx]\n", + "\n", + " P0 = np.array([indices[0], values[0]])\n", + " P1 = np.array([cmax_lightness, cmax_chroma])\n", + " P2 = np.array([indices[-1], values[-1]])\n", + " \n", + " hue_bez_cmax_map[hue_key] = bezier_y_at_x(\n", + " P0, P1, P2, accent_weights[hue_key], lightness_levels_n1\n", + " )\n", + " \n", + "monotone_chroma = 0.011 # fixed monotone chroma\n", + "hl_hex_arr = []\n", + "hl_oklch_map = {}\n", + "hl_hex_map = {}\n", + "\n", + "# filter lightnesses outside bounds\n", + "# l_points = list(range(10, 98+1)) # full 10-98\n", + "l_points = list(range(10, 95+1, 5))+[98] # full 10-98\n", + "\n", + "for i, (hue_name, hue) in enumerate(hue_map.items()):\n", + " lo_map, lh_map = {}, {}\n", + " hl_hex_arr.append(f\"[{hue_name}]\")\n", + " \n", + " chroma_n1 = hue_bez_cmax_map.get(hue_name)\n", + " max_chroma_n1 = hue_cmax_map.get(hue_name)\n", + " for j, lightness in enumerate(lightness_levels_n1):\n", + " if i == 0:\n", + " chroma = 0\n", + " elif i <= 5:\n", + " if monotone_chroma <= max_chroma_n1[j]:\n", + " chroma = monotone_chroma\n", + " else:\n", + " print(f\"'{hue_name}' breached max chroma at L{lightness}\")\n", + " chroma = max_chroma_n1[j]\n", + " else:\n", + " if chroma_n1[j] <= max_chroma_n1[j]:\n", + " chroma = chroma_n1[j]\n", + " else:\n", + " print(f\"'{hue_name}' breached max chroma at L{lightness}\")\n", + " chroma = max_chroma_n1[j]\n", + "\n", + " # filter lightness after change to print\n", + " if lightness < l_bounds[0] or lightness > l_bounds[1]:\n", + " continue\n", + " \n", + " c_oklch = Color('oklch', [lightness/100, chroma, hue])\n", + " c_srgb = c_oklch.convert('srgb')\n", + " \n", + " oklch_str = c_oklch.to_string(percent=True)\n", + " hex_str = c_srgb.to_string(hex=True)\n", + " \n", + " lo_map[f\"l{lightness}\"] = oklch_str\n", + " lh_map[f\"l{lightness}\"] = hex_str\n", + " hl_hex_arr.append(f'l{lightness} = \"{hex_str}\"')\n", + "\n", + " hl_oklch_map[hue_name] = lo_map\n", + " hl_hex_map[hue_name] = lh_map\n", + " hl_hex_arr.append(\"\")\n", + "\n", + "# write files -- QBR = \"quadratic bezier rational\"\n", + "toml_hex = '\\n'.join(hl_hex_arr)\n", + "with Path(PALETTE_DIR, 'monobiome-vQBR.toml').open('w') as f:\n", + " f.write(toml_hex)\n", + " \n", + "with Path(PALETTE_DIR, 'monobiome-vQBR-oklch.json').open('w') as f:\n", + " json.dump(hl_oklch_map, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "0d68c77d-5517-4339-8a54-25584009d3c0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(len(monotone_hue_map), 1, sharex=True, sharey=True, figsize=(4, 8))\n", + "c, c_ax = 0, {}\n", + "for i, hue_label in enumerate(hue_map):\n", + " hue_val = hue_map[hue_label]\n", + " chroma_list = [\n", + " Color(oklch_str)._coords[1]\n", + " for l_str, oklch_str in hl_oklch_map[hue_label].items()\n", + " ]\n", + "\n", + " if hue_val not in c_ax:\n", + " c_ax[hue_val] = axes[i]\n", + " ax = c_ax[hue_val]\n", + "\n", + " ax.title.set_text(f\"Hue: {hue_val}\")\n", + " xs = np.array(lightness_levels_n1)[l_bounds[0]:l_bounds[1]+1]\n", + " cs = np.array(hue_cmax_map[hue_label])[l_bounds[0]:l_bounds[1]+1]\n", + " ax.plot(xs, cs, c='b')\n", + " ax.plot(xs, chroma_list, alpha=0.7)\n", + " \n", + "axes[-1].set_xlabel(\"Lightness\")\n", + "ax.set_xticks([l_bounds[0], 50, l_bounds[1]])\n", + "plt.suptitle(\"Written chroma levels\")\n", + "fig.tight_layout()\n", + "fig.subplots_adjust(top=0.93)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "22d8189c-5d07-4101-8920-5ff6536331b0", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "monobiome", + "language": "python", + "name": "monobiome" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/palettes/monobiome-v111-oklch.json b/notebooks/palettes/monobiome-v111-oklch.json new file mode 100644 index 0000000..d225a14 --- /dev/null +++ b/notebooks/palettes/monobiome-v111-oklch.json @@ -0,0 +1 @@ +{"alpine": {"l0": "oklch(0% 0% 0)", "l1": "oklch(1% 0% 0)", "l2": "oklch(2% 0% 0)", "l3": "oklch(3% 0% 0)", "l4": "oklch(4% 0% 0)", "l5": "oklch(5% 0% 0)", "l6": "oklch(6% 0% 0)", "l7": "oklch(7% 0% 0)", "l8": "oklch(8% 0% 0)", "l9": "oklch(9% 0% 0)", "l10": "oklch(10% 0% 0)", "l11": "oklch(11% 0% 0)", "l12": "oklch(12% 0% 0)", "l13": "oklch(13% 0% 0)", "l14": "oklch(14% 0% 0)", "l15": "oklch(15% 0% 0)", "l16": "oklch(16% 0% 0)", "l17": "oklch(17% 0% 0)", "l18": "oklch(18% 0% 0)", "l19": "oklch(19% 0% 0)", "l20": "oklch(20% 0% 0)", "l21": "oklch(21% 0% 0)", "l22": "oklch(22% 0% 0)", "l23": "oklch(23% 0% 0)", "l24": "oklch(24% 0% 0)", "l25": "oklch(25% 0% 0)", "l26": "oklch(26% 0% 0)", "l27": "oklch(27% 0% 0)", "l28": "oklch(28% 0% 0)", "l29": "oklch(29% 0% 0)", "l30": "oklch(30% 0% 0)", "l31": "oklch(31% 0% 0)", "l32": "oklch(32% 0% 0)", "l33": "oklch(33% 0% 0)", "l34": "oklch(34% 0% 0)", "l35": "oklch(35% 0% 0)", "l36": "oklch(36% 0% 0)", "l37": "oklch(37% 0% 0)", "l38": "oklch(38% 0% 0)", "l39": "oklch(39% 0% 0)", "l40": "oklch(40% 0% 0)", "l41": "oklch(41% 0% 0)", "l42": "oklch(42% 0% 0)", "l43": "oklch(43% 0% 0)", "l44": "oklch(44% 0% 0)", "l45": "oklch(45% 0% 0)", "l46": "oklch(46% 0% 0)", "l47": "oklch(47% 0% 0)", "l48": "oklch(48% 0% 0)", "l49": "oklch(49% 0% 0)", "l50": "oklch(50% 0% 0)", "l51": "oklch(51% 0% 0)", "l52": "oklch(52% 0% 0)", "l53": "oklch(53% 0% 0)", "l54": "oklch(54% 0% 0)", "l55": "oklch(55% 0% 0)", "l56": "oklch(56% 0% 0)", "l57": "oklch(57% 0% 0)", "l58": "oklch(58% 0% 0)", "l59": "oklch(59% 0% 0)", "l60": "oklch(60% 0% 0)", "l61": "oklch(61% 0% 0)", "l62": "oklch(62% 0% 0)", "l63": "oklch(63% 0% 0)", "l64": "oklch(64% 0% 0)", "l65": "oklch(65% 0% 0)", "l66": "oklch(66% 0% 0)", "l67": "oklch(67% 0% 0)", "l68": "oklch(68% 0% 0)", "l69": "oklch(69% 0% 0)", "l70": "oklch(70% 0% 0)", "l71": "oklch(71% 0% 0)", "l72": "oklch(72% 0% 0)", "l73": "oklch(73% 0% 0)", "l74": "oklch(74% 0% 0)", "l75": "oklch(75% 0% 0)", "l76": "oklch(76% 0% 0)", "l77": "oklch(77% 0% 0)", "l78": "oklch(78% 0% 0)", "l79": "oklch(79% 0% 0)", "l80": "oklch(80% 0% 0)", "l81": "oklch(81% 0% 0)", "l82": "oklch(82% 0% 0)", "l83": "oklch(83% 0% 0)", "l84": "oklch(84% 0% 0)", "l85": "oklch(85% 0% 0)", "l86": "oklch(86% 0% 0)", "l87": "oklch(87% 0% 0)", "l88": "oklch(88% 0% 0)", "l89": "oklch(89% 0% 0)", "l90": "oklch(90% 0% 0)", "l91": "oklch(91% 0% 0)", "l92": "oklch(92% 0% 0)", "l93": "oklch(93% 0% 0)", "l94": "oklch(94% 0% 0)", "l95": "oklch(95% 0% 0)", "l96": "oklch(96% 0% 0)", "l97": "oklch(97% 0% 0)", "l98": "oklch(98% 0% 0)", "l99": "oklch(99% 0% 0)", "l100": "oklch(100% 0% 0)"}, "badlands": {"l0": "oklch(0% 2.75% 29)", "l1": "oklch(1% 2.75% 29)", "l2": "oklch(2% 2.75% 29)", "l3": "oklch(3% 2.75% 29)", "l4": "oklch(4% 2.75% 29)", "l5": "oklch(5% 2.75% 29)", "l6": "oklch(6% 2.75% 29)", "l7": "oklch(7% 2.75% 29)", "l8": "oklch(8% 2.75% 29)", "l9": "oklch(9% 2.75% 29)", "l10": "oklch(10% 2.75% 29)", "l11": "oklch(11% 2.75% 29)", "l12": "oklch(12% 2.75% 29)", "l13": "oklch(13% 2.75% 29)", "l14": "oklch(14% 2.75% 29)", "l15": "oklch(15% 2.75% 29)", "l16": "oklch(16% 2.75% 29)", "l17": "oklch(17% 2.75% 29)", "l18": "oklch(18% 2.75% 29)", "l19": "oklch(19% 2.75% 29)", "l20": "oklch(20% 2.75% 29)", "l21": "oklch(21% 2.75% 29)", "l22": "oklch(22% 2.75% 29)", "l23": "oklch(23% 2.75% 29)", "l24": "oklch(24% 2.75% 29)", "l25": "oklch(25% 2.75% 29)", "l26": "oklch(26% 2.75% 29)", "l27": "oklch(27% 2.75% 29)", "l28": "oklch(28% 2.75% 29)", "l29": "oklch(29% 2.75% 29)", "l30": "oklch(30% 2.75% 29)", "l31": "oklch(31% 2.75% 29)", "l32": "oklch(32% 2.75% 29)", "l33": "oklch(33% 2.75% 29)", "l34": "oklch(34% 2.75% 29)", "l35": "oklch(35% 2.75% 29)", "l36": "oklch(36% 2.75% 29)", "l37": "oklch(37% 2.75% 29)", "l38": "oklch(38% 2.75% 29)", "l39": "oklch(39% 2.75% 29)", "l40": "oklch(40% 2.75% 29)", "l41": "oklch(41% 2.75% 29)", "l42": "oklch(42% 2.75% 29)", "l43": "oklch(43% 2.75% 29)", "l44": "oklch(44% 2.75% 29)", "l45": "oklch(45% 2.75% 29)", "l46": "oklch(46% 2.75% 29)", "l47": "oklch(47% 2.75% 29)", "l48": "oklch(48% 2.75% 29)", "l49": "oklch(49% 2.75% 29)", "l50": "oklch(50% 2.75% 29)", "l51": "oklch(51% 2.75% 29)", "l52": "oklch(52% 2.75% 29)", "l53": "oklch(53% 2.75% 29)", "l54": "oklch(54% 2.75% 29)", "l55": "oklch(55% 2.75% 29)", "l56": "oklch(56% 2.75% 29)", "l57": "oklch(57% 2.75% 29)", "l58": "oklch(58% 2.75% 29)", "l59": "oklch(59% 2.75% 29)", "l60": "oklch(60% 2.75% 29)", "l61": "oklch(61% 2.75% 29)", "l62": "oklch(62% 2.75% 29)", "l63": "oklch(63% 2.75% 29)", "l64": "oklch(64% 2.75% 29)", "l65": "oklch(65% 2.75% 29)", "l66": "oklch(66% 2.75% 29)", "l67": "oklch(67% 2.75% 29)", "l68": "oklch(68% 2.75% 29)", "l69": "oklch(69% 2.75% 29)", "l70": "oklch(70% 2.75% 29)", "l71": "oklch(71% 2.75% 29)", "l72": "oklch(72% 2.75% 29)", "l73": "oklch(73% 2.75% 29)", "l74": "oklch(74% 2.75% 29)", "l75": "oklch(75% 2.75% 29)", "l76": "oklch(76% 2.75% 29)", "l77": "oklch(77% 2.75% 29)", "l78": "oklch(78% 2.75% 29)", "l79": "oklch(79% 2.75% 29)", "l80": "oklch(80% 2.75% 29)", "l81": "oklch(81% 2.75% 29)", "l82": "oklch(82% 2.75% 29)", "l83": "oklch(83% 2.75% 29)", "l84": "oklch(84% 2.75% 29)", "l85": "oklch(85% 2.75% 29)", "l86": "oklch(86% 2.75% 29)", "l87": "oklch(87% 2.75% 29)", "l88": "oklch(88% 2.75% 29)", "l89": "oklch(89% 2.75% 29)", "l90": "oklch(90% 2.75% 29)", "l91": "oklch(91% 2.75% 29)", "l92": "oklch(92% 2.75% 29)", "l93": "oklch(93% 2.75% 29)", "l94": "oklch(94% 2.75% 29)", "l95": "oklch(95% 2.75% 29)", "l96": "oklch(96% 2.75% 29)", "l97": "oklch(97% 2.75% 29)", "l98": "oklch(98% 2.75% 29)", "l99": "oklch(99% 2.75% 29)", "l100": "oklch(100% 2.75% 29)"}, "chaparral": {"l0": "oklch(0% 2.75% 62.5)", "l1": "oklch(1% 2.75% 62.5)", "l2": "oklch(2% 2.75% 62.5)", "l3": "oklch(3% 2.75% 62.5)", "l4": "oklch(4% 2.75% 62.5)", "l5": "oklch(5% 2.75% 62.5)", "l6": "oklch(6% 2.75% 62.5)", "l7": "oklch(7% 2.75% 62.5)", "l8": "oklch(8% 2.75% 62.5)", "l9": "oklch(9% 2.75% 62.5)", "l10": "oklch(10% 2.75% 62.5)", "l11": "oklch(11% 2.75% 62.5)", "l12": "oklch(12% 2.75% 62.5)", "l13": "oklch(13% 2.75% 62.5)", "l14": "oklch(14% 2.75% 62.5)", "l15": "oklch(15% 2.75% 62.5)", "l16": "oklch(16% 2.75% 62.5)", "l17": "oklch(17% 2.75% 62.5)", "l18": "oklch(18% 2.75% 62.5)", "l19": "oklch(19% 2.75% 62.5)", "l20": "oklch(20% 2.75% 62.5)", "l21": "oklch(21% 2.75% 62.5)", "l22": "oklch(22% 2.75% 62.5)", "l23": "oklch(23% 2.75% 62.5)", "l24": "oklch(24% 2.75% 62.5)", "l25": "oklch(25% 2.75% 62.5)", "l26": "oklch(26% 2.75% 62.5)", "l27": "oklch(27% 2.75% 62.5)", "l28": "oklch(28% 2.75% 62.5)", "l29": "oklch(29% 2.75% 62.5)", "l30": "oklch(30% 2.75% 62.5)", "l31": "oklch(31% 2.75% 62.5)", "l32": "oklch(32% 2.75% 62.5)", "l33": "oklch(33% 2.75% 62.5)", "l34": "oklch(34% 2.75% 62.5)", "l35": "oklch(35% 2.75% 62.5)", "l36": "oklch(36% 2.75% 62.5)", "l37": "oklch(37% 2.75% 62.5)", "l38": "oklch(38% 2.75% 62.5)", "l39": "oklch(39% 2.75% 62.5)", "l40": "oklch(40% 2.75% 62.5)", "l41": "oklch(41% 2.75% 62.5)", "l42": "oklch(42% 2.75% 62.5)", "l43": "oklch(43% 2.75% 62.5)", "l44": "oklch(44% 2.75% 62.5)", "l45": "oklch(45% 2.75% 62.5)", "l46": "oklch(46% 2.75% 62.5)", "l47": "oklch(47% 2.75% 62.5)", "l48": "oklch(48% 2.75% 62.5)", "l49": "oklch(49% 2.75% 62.5)", "l50": "oklch(50% 2.75% 62.5)", "l51": "oklch(51% 2.75% 62.5)", "l52": "oklch(52% 2.75% 62.5)", "l53": "oklch(53% 2.75% 62.5)", "l54": "oklch(54% 2.75% 62.5)", "l55": "oklch(55% 2.75% 62.5)", "l56": "oklch(56% 2.75% 62.5)", "l57": "oklch(57% 2.75% 62.5)", "l58": "oklch(58% 2.75% 62.5)", "l59": "oklch(59% 2.75% 62.5)", "l60": "oklch(60% 2.75% 62.5)", "l61": "oklch(61% 2.75% 62.5)", "l62": "oklch(62% 2.75% 62.5)", "l63": "oklch(63% 2.75% 62.5)", "l64": "oklch(64% 2.75% 62.5)", "l65": "oklch(65% 2.75% 62.5)", "l66": "oklch(66% 2.75% 62.5)", "l67": "oklch(67% 2.75% 62.5)", "l68": "oklch(68% 2.75% 62.5)", "l69": "oklch(69% 2.75% 62.5)", "l70": "oklch(70% 2.75% 62.5)", "l71": "oklch(71% 2.75% 62.5)", "l72": "oklch(72% 2.75% 62.5)", "l73": "oklch(73% 2.75% 62.5)", "l74": "oklch(74% 2.75% 62.5)", "l75": "oklch(75% 2.75% 62.5)", "l76": "oklch(76% 2.75% 62.5)", "l77": "oklch(77% 2.75% 62.5)", "l78": "oklch(78% 2.75% 62.5)", "l79": "oklch(79% 2.75% 62.5)", "l80": "oklch(80% 2.75% 62.5)", "l81": "oklch(81% 2.75% 62.5)", "l82": "oklch(82% 2.75% 62.5)", "l83": "oklch(83% 2.75% 62.5)", "l84": "oklch(84% 2.75% 62.5)", "l85": "oklch(85% 2.75% 62.5)", "l86": "oklch(86% 2.75% 62.5)", "l87": "oklch(87% 2.75% 62.5)", "l88": "oklch(88% 2.75% 62.5)", "l89": "oklch(89% 2.75% 62.5)", "l90": "oklch(90% 2.75% 62.5)", "l91": "oklch(91% 2.75% 62.5)", "l92": "oklch(92% 2.75% 62.5)", "l93": "oklch(93% 2.75% 62.5)", "l94": "oklch(94% 2.75% 62.5)", "l95": "oklch(95% 2.75% 62.5)", "l96": "oklch(96% 2.75% 62.5)", "l97": "oklch(97% 2.75% 62.5)", "l98": "oklch(98% 2.75% 62.5)", "l99": "oklch(99% 2.75% 62.5)", "l100": "oklch(100% 2.75% 62.5)"}, "savanna": {"l0": "oklch(0% 2.75% 104)", "l1": "oklch(1% 2.75% 104)", "l2": "oklch(2% 2.75% 104)", "l3": "oklch(3% 2.75% 104)", "l4": "oklch(4% 2.75% 104)", "l5": "oklch(5% 2.75% 104)", "l6": "oklch(6% 2.75% 104)", "l7": "oklch(7% 2.75% 104)", "l8": "oklch(8% 2.75% 104)", "l9": "oklch(9% 2.75% 104)", "l10": "oklch(10% 2.75% 104)", "l11": "oklch(11% 2.75% 104)", "l12": "oklch(12% 2.75% 104)", "l13": "oklch(13% 2.75% 104)", "l14": "oklch(14% 2.75% 104)", "l15": "oklch(15% 2.75% 104)", "l16": "oklch(16% 2.75% 104)", "l17": "oklch(17% 2.75% 104)", "l18": "oklch(18% 2.75% 104)", "l19": "oklch(19% 2.75% 104)", "l20": "oklch(20% 2.75% 104)", "l21": "oklch(21% 2.75% 104)", "l22": "oklch(22% 2.75% 104)", "l23": "oklch(23% 2.75% 104)", "l24": "oklch(24% 2.75% 104)", "l25": "oklch(25% 2.75% 104)", "l26": "oklch(26% 2.75% 104)", "l27": "oklch(27% 2.75% 104)", "l28": "oklch(28% 2.75% 104)", "l29": "oklch(29% 2.75% 104)", "l30": "oklch(30% 2.75% 104)", "l31": "oklch(31% 2.75% 104)", "l32": "oklch(32% 2.75% 104)", "l33": "oklch(33% 2.75% 104)", "l34": "oklch(34% 2.75% 104)", "l35": "oklch(35% 2.75% 104)", "l36": "oklch(36% 2.75% 104)", "l37": "oklch(37% 2.75% 104)", "l38": "oklch(38% 2.75% 104)", "l39": "oklch(39% 2.75% 104)", "l40": "oklch(40% 2.75% 104)", "l41": "oklch(41% 2.75% 104)", "l42": "oklch(42% 2.75% 104)", "l43": "oklch(43% 2.75% 104)", "l44": "oklch(44% 2.75% 104)", "l45": "oklch(45% 2.75% 104)", "l46": "oklch(46% 2.75% 104)", "l47": "oklch(47% 2.75% 104)", "l48": "oklch(48% 2.75% 104)", "l49": "oklch(49% 2.75% 104)", "l50": "oklch(50% 2.75% 104)", "l51": "oklch(51% 2.75% 104)", "l52": "oklch(52% 2.75% 104)", "l53": "oklch(53% 2.75% 104)", "l54": "oklch(54% 2.75% 104)", "l55": "oklch(55% 2.75% 104)", "l56": "oklch(56% 2.75% 104)", "l57": "oklch(57% 2.75% 104)", "l58": "oklch(58% 2.75% 104)", "l59": "oklch(59% 2.75% 104)", "l60": "oklch(60% 2.75% 104)", "l61": "oklch(61% 2.75% 104)", "l62": "oklch(62% 2.75% 104)", "l63": "oklch(63% 2.75% 104)", "l64": "oklch(64% 2.75% 104)", "l65": "oklch(65% 2.75% 104)", "l66": "oklch(66% 2.75% 104)", "l67": "oklch(67% 2.75% 104)", "l68": "oklch(68% 2.75% 104)", "l69": "oklch(69% 2.75% 104)", "l70": "oklch(70% 2.75% 104)", "l71": "oklch(71% 2.75% 104)", "l72": "oklch(72% 2.75% 104)", "l73": "oklch(73% 2.75% 104)", "l74": "oklch(74% 2.75% 104)", "l75": "oklch(75% 2.75% 104)", "l76": "oklch(76% 2.75% 104)", "l77": "oklch(77% 2.75% 104)", "l78": "oklch(78% 2.75% 104)", "l79": "oklch(79% 2.75% 104)", "l80": "oklch(80% 2.75% 104)", "l81": "oklch(81% 2.75% 104)", "l82": "oklch(82% 2.75% 104)", "l83": "oklch(83% 2.75% 104)", "l84": "oklch(84% 2.75% 104)", "l85": "oklch(85% 2.75% 104)", "l86": "oklch(86% 2.75% 104)", "l87": "oklch(87% 2.75% 104)", "l88": "oklch(88% 2.75% 104)", "l89": "oklch(89% 2.75% 104)", "l90": "oklch(90% 2.75% 104)", "l91": "oklch(91% 2.75% 104)", "l92": "oklch(92% 2.75% 104)", "l93": "oklch(93% 2.75% 104)", "l94": "oklch(94% 2.75% 104)", "l95": "oklch(95% 2.75% 104)", "l96": "oklch(96% 2.75% 104)", "l97": "oklch(97% 2.75% 104)", "l98": "oklch(98% 2.75% 104)", "l99": "oklch(99% 2.75% 104)", "l100": "oklch(100% 2.75% 104)"}, "grassland": {"l0": "oklch(0% 2.75% 148)", "l1": "oklch(1% 2.75% 148)", "l2": "oklch(2% 2.75% 148)", "l3": "oklch(3% 2.75% 148)", "l4": "oklch(4% 2.75% 148)", "l5": "oklch(5% 2.75% 148)", "l6": "oklch(6% 2.75% 148)", "l7": "oklch(7% 2.75% 148)", "l8": "oklch(8% 2.75% 148)", "l9": "oklch(9% 2.75% 148)", "l10": "oklch(10% 2.75% 148)", "l11": "oklch(11% 2.75% 148)", "l12": "oklch(12% 2.75% 148)", "l13": "oklch(13% 2.75% 148)", "l14": "oklch(14% 2.75% 148)", "l15": "oklch(15% 2.75% 148)", "l16": "oklch(16% 2.75% 148)", "l17": "oklch(17% 2.75% 148)", "l18": "oklch(18% 2.75% 148)", "l19": "oklch(19% 2.75% 148)", "l20": "oklch(20% 2.75% 148)", "l21": "oklch(21% 2.75% 148)", "l22": "oklch(22% 2.75% 148)", "l23": "oklch(23% 2.75% 148)", "l24": "oklch(24% 2.75% 148)", "l25": "oklch(25% 2.75% 148)", "l26": "oklch(26% 2.75% 148)", "l27": "oklch(27% 2.75% 148)", "l28": "oklch(28% 2.75% 148)", "l29": "oklch(29% 2.75% 148)", "l30": "oklch(30% 2.75% 148)", "l31": "oklch(31% 2.75% 148)", "l32": "oklch(32% 2.75% 148)", "l33": "oklch(33% 2.75% 148)", "l34": "oklch(34% 2.75% 148)", "l35": "oklch(35% 2.75% 148)", "l36": "oklch(36% 2.75% 148)", "l37": "oklch(37% 2.75% 148)", "l38": "oklch(38% 2.75% 148)", "l39": "oklch(39% 2.75% 148)", "l40": "oklch(40% 2.75% 148)", "l41": "oklch(41% 2.75% 148)", "l42": "oklch(42% 2.75% 148)", "l43": "oklch(43% 2.75% 148)", "l44": "oklch(44% 2.75% 148)", "l45": "oklch(45% 2.75% 148)", "l46": "oklch(46% 2.75% 148)", "l47": "oklch(47% 2.75% 148)", "l48": "oklch(48% 2.75% 148)", "l49": "oklch(49% 2.75% 148)", "l50": "oklch(50% 2.75% 148)", "l51": "oklch(51% 2.75% 148)", "l52": "oklch(52% 2.75% 148)", "l53": "oklch(53% 2.75% 148)", "l54": "oklch(54% 2.75% 148)", "l55": "oklch(55% 2.75% 148)", "l56": "oklch(56% 2.75% 148)", "l57": "oklch(57% 2.75% 148)", "l58": "oklch(58% 2.75% 148)", "l59": "oklch(59% 2.75% 148)", "l60": "oklch(60% 2.75% 148)", "l61": "oklch(61% 2.75% 148)", "l62": "oklch(62% 2.75% 148)", "l63": "oklch(63% 2.75% 148)", "l64": "oklch(64% 2.75% 148)", "l65": "oklch(65% 2.75% 148)", "l66": "oklch(66% 2.75% 148)", "l67": "oklch(67% 2.75% 148)", "l68": "oklch(68% 2.75% 148)", "l69": "oklch(69% 2.75% 148)", "l70": "oklch(70% 2.75% 148)", "l71": "oklch(71% 2.75% 148)", "l72": "oklch(72% 2.75% 148)", "l73": "oklch(73% 2.75% 148)", "l74": "oklch(74% 2.75% 148)", "l75": "oklch(75% 2.75% 148)", "l76": "oklch(76% 2.75% 148)", "l77": "oklch(77% 2.75% 148)", "l78": "oklch(78% 2.75% 148)", "l79": "oklch(79% 2.75% 148)", "l80": "oklch(80% 2.75% 148)", "l81": "oklch(81% 2.75% 148)", "l82": "oklch(82% 2.75% 148)", "l83": "oklch(83% 2.75% 148)", "l84": "oklch(84% 2.75% 148)", "l85": "oklch(85% 2.75% 148)", "l86": "oklch(86% 2.75% 148)", "l87": "oklch(87% 2.75% 148)", "l88": "oklch(88% 2.75% 148)", "l89": "oklch(89% 2.75% 148)", "l90": "oklch(90% 2.75% 148)", "l91": "oklch(91% 2.75% 148)", "l92": "oklch(92% 2.75% 148)", "l93": "oklch(93% 2.75% 148)", "l94": "oklch(94% 2.75% 148)", "l95": "oklch(95% 2.75% 148)", "l96": "oklch(96% 2.75% 148)", "l97": "oklch(97% 2.75% 148)", "l98": "oklch(98% 2.75% 148)", "l99": "oklch(99% 2.75% 148)", "l100": "oklch(100% 2.75% 148)"}, "tundra": {"l0": "oklch(0% 2.75% 262)", "l1": "oklch(1% 2.75% 262)", "l2": "oklch(2% 2.75% 262)", "l3": "oklch(3% 2.75% 262)", "l4": "oklch(4% 2.75% 262)", "l5": "oklch(5% 2.75% 262)", "l6": "oklch(6% 2.75% 262)", "l7": "oklch(7% 2.75% 262)", "l8": "oklch(8% 2.75% 262)", "l9": "oklch(9% 2.75% 262)", "l10": "oklch(10% 2.75% 262)", "l11": "oklch(11% 2.75% 262)", "l12": "oklch(12% 2.75% 262)", "l13": "oklch(13% 2.75% 262)", "l14": "oklch(14% 2.75% 262)", "l15": "oklch(15% 2.75% 262)", "l16": "oklch(16% 2.75% 262)", "l17": "oklch(17% 2.75% 262)", "l18": "oklch(18% 2.75% 262)", "l19": "oklch(19% 2.75% 262)", "l20": "oklch(20% 2.75% 262)", "l21": "oklch(21% 2.75% 262)", "l22": "oklch(22% 2.75% 262)", "l23": "oklch(23% 2.75% 262)", "l24": "oklch(24% 2.75% 262)", "l25": "oklch(25% 2.75% 262)", "l26": "oklch(26% 2.75% 262)", "l27": "oklch(27% 2.75% 262)", "l28": "oklch(28% 2.75% 262)", "l29": "oklch(29% 2.75% 262)", "l30": "oklch(30% 2.75% 262)", "l31": "oklch(31% 2.75% 262)", "l32": "oklch(32% 2.75% 262)", "l33": "oklch(33% 2.75% 262)", "l34": "oklch(34% 2.75% 262)", "l35": "oklch(35% 2.75% 262)", "l36": "oklch(36% 2.75% 262)", "l37": "oklch(37% 2.75% 262)", "l38": "oklch(38% 2.75% 262)", "l39": "oklch(39% 2.75% 262)", "l40": "oklch(40% 2.75% 262)", "l41": "oklch(41% 2.75% 262)", "l42": "oklch(42% 2.75% 262)", "l43": "oklch(43% 2.75% 262)", "l44": "oklch(44% 2.75% 262)", "l45": "oklch(45% 2.75% 262)", "l46": "oklch(46% 2.75% 262)", "l47": "oklch(47% 2.75% 262)", "l48": "oklch(48% 2.75% 262)", "l49": "oklch(49% 2.75% 262)", "l50": "oklch(50% 2.75% 262)", "l51": "oklch(51% 2.75% 262)", "l52": "oklch(52% 2.75% 262)", "l53": "oklch(53% 2.75% 262)", "l54": "oklch(54% 2.75% 262)", "l55": "oklch(55% 2.75% 262)", "l56": "oklch(56% 2.75% 262)", "l57": "oklch(57% 2.75% 262)", "l58": "oklch(58% 2.75% 262)", "l59": "oklch(59% 2.75% 262)", "l60": "oklch(60% 2.75% 262)", "l61": "oklch(61% 2.75% 262)", "l62": "oklch(62% 2.75% 262)", "l63": "oklch(63% 2.75% 262)", "l64": "oklch(64% 2.75% 262)", "l65": "oklch(65% 2.75% 262)", "l66": "oklch(66% 2.75% 262)", "l67": "oklch(67% 2.75% 262)", "l68": "oklch(68% 2.75% 262)", "l69": "oklch(69% 2.75% 262)", "l70": "oklch(70% 2.75% 262)", "l71": "oklch(71% 2.75% 262)", "l72": "oklch(72% 2.75% 262)", "l73": "oklch(73% 2.75% 262)", "l74": "oklch(74% 2.75% 262)", "l75": "oklch(75% 2.75% 262)", "l76": "oklch(76% 2.75% 262)", "l77": "oklch(77% 2.75% 262)", "l78": "oklch(78% 2.75% 262)", "l79": "oklch(79% 2.75% 262)", "l80": "oklch(80% 2.75% 262)", "l81": "oklch(81% 2.75% 262)", "l82": "oklch(82% 2.75% 262)", "l83": "oklch(83% 2.75% 262)", "l84": "oklch(84% 2.75% 262)", "l85": "oklch(85% 2.75% 262)", "l86": "oklch(86% 2.75% 262)", "l87": "oklch(87% 2.75% 262)", "l88": "oklch(88% 2.75% 262)", "l89": "oklch(89% 2.75% 262)", "l90": "oklch(90% 2.75% 262)", "l91": "oklch(91% 2.75% 262)", "l92": "oklch(92% 2.75% 262)", "l93": "oklch(93% 2.75% 262)", "l94": "oklch(94% 2.75% 262)", "l95": "oklch(95% 2.75% 262)", "l96": "oklch(96% 2.75% 262)", "l97": "oklch(97% 2.75% 262)", "l98": "oklch(98% 2.75% 262)", "l99": "oklch(99% 2.75% 262)", "l100": "oklch(100% 2.75% 262)"}, "red": {"l0": "oklch(0% 0.41389% 209)", "l1": "oklch(1% 0.97472% 29)", "l2": "oklch(2% 2.2817% 29)", "l3": "oklch(3% 3.513% 29)", "l4": "oklch(4% 4.6743% 29)", "l5": "oklch(5% 5.7715% 29)", "l6": "oklch(6% 6.8105% 29)", "l7": "oklch(7% 7.797% 29)", "l8": "oklch(8% 8.7368% 29)", "l9": "oklch(9% 9.6359% 29)", "l10": "oklch(10% 10.5% 29)", "l11": "oklch(11% 11.335% 29)", "l12": "oklch(12% 12.147% 29)", "l13": "oklch(13% 12.941% 29)", "l14": "oklch(14% 13.723% 29)", "l15": "oklch(15% 14.5% 29)", "l16": "oklch(16% 15.277% 29)", "l17": "oklch(17% 16.059% 29)", "l18": "oklch(18% 16.853% 29)", "l19": "oklch(19% 17.665% 29)", "l20": "oklch(20% 18.5% 29)", "l21": "oklch(21% 19.363% 29)", "l22": "oklch(22% 20.252% 29)", "l23": "oklch(23% 21.165% 29)", "l24": "oklch(24% 22.101% 29)", "l25": "oklch(25% 23.055% 29)", "l26": "oklch(26% 24.025% 29)", "l27": "oklch(27% 25.01% 29)", "l28": "oklch(28% 26.006% 29)", "l29": "oklch(29% 27.012% 29)", "l30": "oklch(30% 28.023% 29)", "l31": "oklch(31% 29.039% 29)", "l32": "oklch(32% 30.056% 29)", "l33": "oklch(33% 31.073% 29)", "l34": "oklch(34% 32.085% 29)", "l35": "oklch(35% 33.092% 29)", "l36": "oklch(36% 34.09% 29)", "l37": "oklch(37% 35.076% 29)", "l38": "oklch(38% 36.05% 29)", "l39": "oklch(39% 37.007% 29)", "l40": "oklch(40% 37.945% 29)", "l41": "oklch(41% 38.862% 29)", "l42": "oklch(42% 39.756% 29)", "l43": "oklch(43% 40.623% 29)", "l44": "oklch(44% 41.462% 29)", "l45": "oklch(45% 42.269% 29)", "l46": "oklch(46% 43.043% 29)", "l47": "oklch(47% 43.781% 29)", "l48": "oklch(48% 44.479% 29)", "l49": "oklch(49% 45.136% 29)", "l50": "oklch(50% 45.75% 29)", "l51": "oklch(51% 46.317% 29)", "l52": "oklch(52% 46.83% 29)", "l53": "oklch(53% 47.284% 29)", "l54": "oklch(54% 47.673% 29)", "l55": "oklch(55% 47.988% 29)", "l56": "oklch(56% 48.225% 29)", "l57": "oklch(57% 48.376% 29)", "l58": "oklch(58% 48.435% 29)", "l59": "oklch(59% 48.395% 29)", "l60": "oklch(60% 48.25% 29)", "l61": "oklch(61% 47.995% 29)", "l62": "oklch(62% 47.633% 29)", "l63": "oklch(63% 47.168% 29)", "l64": "oklch(64% 46.606% 29)", "l65": "oklch(65% 45.95% 29)", "l66": "oklch(66% 45.206% 29)", "l67": "oklch(67% 44.378% 29)", "l68": "oklch(68% 43.472% 29)", "l69": "oklch(69% 42.49% 29)", "l70": "oklch(70% 41.44% 29)", "l71": "oklch(71% 40.324% 29)", "l72": "oklch(72% 39.148% 29)", "l73": "oklch(73% 37.916% 29)", "l74": "oklch(74% 36.633% 29)", "l75": "oklch(75% 35.304% 29)", "l76": "oklch(76% 33.934% 29)", "l77": "oklch(77% 32.526% 29)", "l78": "oklch(78% 31.086% 29)", "l79": "oklch(79% 29.619% 29)", "l80": "oklch(80% 28.129% 29)", "l81": "oklch(81% 26.621% 29)", "l82": "oklch(82% 25.099% 29)", "l83": "oklch(83% 23.568% 29)", "l84": "oklch(84% 22.033% 29)", "l85": "oklch(85% 20.499% 29)", "l86": "oklch(86% 18.97% 29)", "l87": "oklch(87% 17.451% 29)", "l88": "oklch(88% 15.946% 29)", "l89": "oklch(89% 14.461% 29)", "l90": "oklch(90% 13% 29)", "l91": "oklch(91% 11.566% 29)", "l92": "oklch(92% 10.154% 29)", "l93": "oklch(93% 8.7599% 29)", "l94": "oklch(94% 7.3771% 29)", "l95": "oklch(95% 6% 29)", "l96": "oklch(96% 4.6229% 29)", "l97": "oklch(97% 3.2401% 29)", "l98": "oklch(98% 1.8458% 29)", "l99": "oklch(99% 0.43437% 29)", "l100": "oklch(100% 1% 209)"}, "orange": {"l0": "oklch(0% 1.5271% 242.5)", "l1": "oklch(1% 0.51566% 242.5)", "l2": "oklch(2% 0.41106% 62.5)", "l3": "oklch(3% 1.2591% 62.5)", "l4": "oklch(4% 2.0344% 62.5)", "l5": "oklch(5% 2.7432% 62.5)", "l6": "oklch(6% 3.3914% 62.5)", "l7": "oklch(7% 3.9852% 62.5)", "l8": "oklch(8% 4.5305% 62.5)", "l9": "oklch(9% 5.0334% 62.5)", "l10": "oklch(10% 5.5% 62.5)", "l11": "oklch(11% 5.9363% 62.5)", "l12": "oklch(12% 6.3484% 62.5)", "l13": "oklch(13% 6.7424% 62.5)", "l14": "oklch(14% 7.1242% 62.5)", "l15": "oklch(15% 7.5% 62.5)", "l16": "oklch(16% 7.8758% 62.5)", "l17": "oklch(17% 8.2576% 62.5)", "l18": "oklch(18% 8.6516% 62.5)", "l19": "oklch(19% 9.0637% 62.5)", "l20": "oklch(20% 9.5% 62.5)", "l21": "oklch(21% 9.9653% 62.5)", "l22": "oklch(22% 10.459% 62.5)", "l23": "oklch(23% 10.98% 62.5)", "l24": "oklch(24% 11.526% 62.5)", "l25": "oklch(25% 12.095% 62.5)", "l26": "oklch(26% 12.686% 62.5)", "l27": "oklch(27% 13.297% 62.5)", "l28": "oklch(28% 13.926% 62.5)", "l29": "oklch(29% 14.572% 62.5)", "l30": "oklch(30% 15.233% 62.5)", "l31": "oklch(31% 15.907% 62.5)", "l32": "oklch(32% 16.593% 62.5)", "l33": "oklch(33% 17.288% 62.5)", "l34": "oklch(34% 17.991% 62.5)", "l35": "oklch(35% 18.701% 62.5)", "l36": "oklch(36% 19.415% 62.5)", "l37": "oklch(37% 20.132% 62.5)", "l38": "oklch(38% 20.85% 62.5)", "l39": "oklch(39% 21.568% 62.5)", "l40": "oklch(40% 22.284% 62.5)", "l41": "oklch(41% 22.996% 62.5)", "l42": "oklch(42% 23.702% 62.5)", "l43": "oklch(43% 24.401% 62.5)", "l44": "oklch(44% 25.09% 62.5)", "l45": "oklch(45% 25.769% 62.5)", "l46": "oklch(46% 26.436% 62.5)", "l47": "oklch(47% 27.088% 62.5)", "l48": "oklch(48% 27.724% 62.5)", "l49": "oklch(49% 28.343% 62.5)", "l50": "oklch(50% 28.943% 62.5)", "l51": "oklch(51% 29.521% 62.5)", "l52": "oklch(52% 30.077% 62.5)", "l53": "oklch(53% 30.608% 62.5)", "l54": "oklch(54% 31.114% 62.5)", "l55": "oklch(55% 31.591% 62.5)", "l56": "oklch(56% 32.039% 62.5)", "l57": "oklch(57% 32.455% 62.5)", "l58": "oklch(58% 32.839% 62.5)", "l59": "oklch(59% 33.188% 62.5)", "l60": "oklch(60% 33.5% 62.5)", "l61": "oklch(61% 33.774% 62.5)", "l62": "oklch(62% 34.007% 62.5)", "l63": "oklch(63% 34.195% 62.5)", "l64": "oklch(64% 34.336% 62.5)", "l65": "oklch(65% 34.426% 62.5)", "l66": "oklch(66% 34.461% 62.5)", "l67": "oklch(67% 34.44% 62.5)", "l68": "oklch(68% 34.358% 62.5)", "l69": "oklch(69% 34.212% 62.5)", "l70": "oklch(70% 34% 62.5)", "l71": "oklch(71% 33.718% 62.5)", "l72": "oklch(72% 33.367% 62.5)", "l73": "oklch(73% 32.948% 62.5)", "l74": "oklch(74% 32.461% 62.5)", "l75": "oklch(75% 31.906% 62.5)", "l76": "oklch(76% 31.285% 62.5)", "l77": "oklch(77% 30.598% 62.5)", "l78": "oklch(78% 29.846% 62.5)", "l79": "oklch(79% 29.03% 62.5)", "l80": "oklch(80% 28.15% 62.5)", "l81": "oklch(81% 27.207% 62.5)", "l82": "oklch(82% 26.201% 62.5)", "l83": "oklch(83% 25.134% 62.5)", "l84": "oklch(84% 24.007% 62.5)", "l85": "oklch(85% 22.819% 62.5)", "l86": "oklch(86% 21.571% 62.5)", "l87": "oklch(87% 20.265% 62.5)", "l88": "oklch(88% 18.9% 62.5)", "l89": "oklch(89% 17.479% 62.5)", "l90": "oklch(90% 16% 62.5)", "l91": "oklch(91% 14.467% 62.5)", "l92": "oklch(92% 12.89% 62.5)", "l93": "oklch(93% 11.278% 62.5)", "l94": "oklch(94% 9.6448% 62.5)", "l95": "oklch(95% 8% 62.5)", "l96": "oklch(96% 6.3552% 62.5)", "l97": "oklch(97% 4.7216% 62.5)", "l98": "oklch(98% 3.1104% 62.5)", "l99": "oklch(99% 1.5328% 62.5)", "l100": "oklch(100% 0% 62.5)"}, "yellow": {"l0": "oklch(0% 0.1723% 104)", "l1": "oklch(1% 0.74149% 104)", "l2": "oklch(2% 1.2595% 104)", "l3": "oklch(3% 1.73% 104)", "l4": "oklch(4% 2.1566% 104)", "l5": "oklch(5% 2.5431% 104)", "l6": "oklch(6% 2.8929% 104)", "l7": "oklch(7% 3.2099% 104)", "l8": "oklch(8% 3.4976% 104)", "l9": "oklch(9% 3.7598% 104)", "l10": "oklch(10% 4% 104)", "l11": "oklch(11% 4.2219% 104)", "l12": "oklch(12% 4.4292% 104)", "l13": "oklch(13% 4.6256% 104)", "l14": "oklch(14% 4.8146% 104)", "l15": "oklch(15% 5% 104)", "l16": "oklch(16% 5.1854% 104)", "l17": "oklch(17% 5.3744% 104)", "l18": "oklch(18% 5.5708% 104)", "l19": "oklch(19% 5.7781% 104)", "l20": "oklch(20% 6% 104)", "l21": "oklch(21% 6.2395% 104)", "l22": "oklch(22% 6.4963% 104)", "l23": "oklch(23% 6.7697% 104)", "l24": "oklch(24% 7.0587% 104)", "l25": "oklch(25% 7.3625% 104)", "l26": "oklch(26% 7.6802% 104)", "l27": "oklch(27% 8.011% 104)", "l28": "oklch(28% 8.3538% 104)", "l29": "oklch(29% 8.708% 104)", "l30": "oklch(30% 9.0725% 104)", "l31": "oklch(31% 9.4466% 104)", "l32": "oklch(32% 9.8293% 104)", "l33": "oklch(33% 10.22% 104)", "l34": "oklch(34% 10.617% 104)", "l35": "oklch(35% 11.021% 104)", "l36": "oklch(36% 11.429% 104)", "l37": "oklch(37% 11.842% 104)", "l38": "oklch(38% 12.258% 104)", "l39": "oklch(39% 12.677% 104)", "l40": "oklch(40% 13.097% 104)", "l41": "oklch(41% 13.518% 104)", "l42": "oklch(42% 13.939% 104)", "l43": "oklch(43% 14.359% 104)", "l44": "oklch(44% 14.777% 104)", "l45": "oklch(45% 15.193% 104)", "l46": "oklch(46% 15.605% 104)", "l47": "oklch(47% 16.012% 104)", "l48": "oklch(48% 16.414% 104)", "l49": "oklch(49% 16.81% 104)", "l50": "oklch(50% 17.198% 104)", "l51": "oklch(51% 17.579% 104)", "l52": "oklch(52% 17.95% 104)", "l53": "oklch(53% 18.312% 104)", "l54": "oklch(54% 18.664% 104)", "l55": "oklch(55% 19.004% 104)", "l56": "oklch(56% 19.331% 104)", "l57": "oklch(57% 19.645% 104)", "l58": "oklch(58% 19.946% 104)", "l59": "oklch(59% 20.231% 104)", "l60": "oklch(60% 20.5% 104)", "l61": "oklch(61% 20.752% 104)", "l62": "oklch(62% 20.986% 104)", "l63": "oklch(63% 21.2% 104)", "l64": "oklch(64% 21.393% 104)", "l65": "oklch(65% 21.562% 104)", "l66": "oklch(66% 21.706% 104)", "l67": "oklch(67% 21.823% 104)", "l68": "oklch(68% 21.913% 104)", "l69": "oklch(69% 21.972% 104)", "l70": "oklch(70% 22% 104)", "l71": "oklch(71% 21.995% 104)", "l72": "oklch(72% 21.956% 104)", "l73": "oklch(73% 21.882% 104)", "l74": "oklch(74% 21.773% 104)", "l75": "oklch(75% 21.627% 104)", "l76": "oklch(76% 21.444% 104)", "l77": "oklch(77% 21.223% 104)", "l78": "oklch(78% 20.962% 104)", "l79": "oklch(79% 20.662% 104)", "l80": "oklch(80% 20.322% 104)", "l81": "oklch(81% 19.94% 104)", "l82": "oklch(82% 19.516% 104)", "l83": "oklch(83% 19.048% 104)", "l84": "oklch(84% 18.537% 104)", "l85": "oklch(85% 17.981% 104)", "l86": "oklch(86% 17.379% 104)", "l87": "oklch(87% 16.731% 104)", "l88": "oklch(88% 16.036% 104)", "l89": "oklch(89% 15.292% 104)", "l90": "oklch(90% 14.5% 104)", "l91": "oklch(91% 13.66% 104)", "l92": "oklch(92% 12.78% 104)", "l93": "oklch(93% 11.87% 104)", "l94": "oklch(94% 10.94% 104)", "l95": "oklch(95% 10% 104)", "l96": "oklch(96% 9.0602% 104)", "l97": "oklch(97% 8.1304% 104)", "l98": "oklch(98% 7.2204% 104)", "l99": "oklch(99% 6.3403% 104)", "l100": "oklch(100% 5.5% 104)"}, "green": {"l0": "oklch(0% 3.1389% 148)", "l1": "oklch(1% 3.728% 148)", "l2": "oklch(2% 4.2902% 148)", "l3": "oklch(3% 4.8275% 148)", "l4": "oklch(4% 5.3417% 148)", "l5": "oklch(5% 5.8347% 148)", "l6": "oklch(6% 6.3085% 148)", "l7": "oklch(7% 6.765% 148)", "l8": "oklch(8% 7.2062% 148)", "l9": "oklch(9% 7.6339% 148)", "l10": "oklch(10% 8.05% 148)", "l11": "oklch(11% 8.4565% 148)", "l12": "oklch(12% 8.8554% 148)", "l13": "oklch(13% 9.2485% 148)", "l14": "oklch(14% 9.6377% 148)", "l15": "oklch(15% 10.025% 148)", "l16": "oklch(16% 10.412% 148)", "l17": "oklch(17% 10.802% 148)", "l18": "oklch(18% 11.195% 148)", "l19": "oklch(19% 11.593% 148)", "l20": "oklch(20% 12% 148)", "l21": "oklch(21% 12.416% 148)", "l22": "oklch(22% 12.84% 148)", "l23": "oklch(23% 13.272% 148)", "l24": "oklch(24% 13.712% 148)", "l25": "oklch(25% 14.157% 148)", "l26": "oklch(26% 14.608% 148)", "l27": "oklch(27% 15.064% 148)", "l28": "oklch(28% 15.523% 148)", "l29": "oklch(29% 15.984% 148)", "l30": "oklch(30% 16.448% 148)", "l31": "oklch(31% 16.913% 148)", "l32": "oklch(32% 17.378% 148)", "l33": "oklch(33% 17.842% 148)", "l34": "oklch(34% 18.305% 148)", "l35": "oklch(35% 18.765% 148)", "l36": "oklch(36% 19.222% 148)", "l37": "oklch(37% 19.675% 148)", "l38": "oklch(38% 20.123% 148)", "l39": "oklch(39% 20.566% 148)", "l40": "oklch(40% 21.001% 148)", "l41": "oklch(41% 21.43% 148)", "l42": "oklch(42% 21.849% 148)", "l43": "oklch(43% 22.26% 148)", "l44": "oklch(44% 22.66% 148)", "l45": "oklch(45% 23.05% 148)", "l46": "oklch(46% 23.428% 148)", "l47": "oklch(47% 23.793% 148)", "l48": "oklch(48% 24.145% 148)", "l49": "oklch(49% 24.482% 148)", "l50": "oklch(50% 24.804% 148)", "l51": "oklch(51% 25.11% 148)", "l52": "oklch(52% 25.399% 148)", "l53": "oklch(53% 25.67% 148)", "l54": "oklch(54% 25.923% 148)", "l55": "oklch(55% 26.156% 148)", "l56": "oklch(56% 26.369% 148)", "l57": "oklch(57% 26.561% 148)", "l58": "oklch(58% 26.73% 148)", "l59": "oklch(59% 26.877% 148)", "l60": "oklch(60% 27% 148)", "l61": "oklch(61% 27.099% 148)", "l62": "oklch(62% 27.173% 148)", "l63": "oklch(63% 27.225% 148)", "l64": "oklch(64% 27.254% 148)", "l65": "oklch(65% 27.261% 148)", "l66": "oklch(66% 27.248% 148)", "l67": "oklch(67% 27.214% 148)", "l68": "oklch(68% 27.161% 148)", "l69": "oklch(69% 27.09% 148)", "l70": "oklch(70% 27% 148)", "l71": "oklch(71% 26.893% 148)", "l72": "oklch(72% 26.765% 148)", "l73": "oklch(73% 26.616% 148)", "l74": "oklch(74% 26.44% 148)", "l75": "oklch(75% 26.237% 148)", "l76": "oklch(76% 26.004% 148)", "l77": "oklch(77% 25.736% 148)", "l78": "oklch(78% 25.433% 148)", "l79": "oklch(79% 25.091% 148)", "l80": "oklch(80% 24.708% 148)", "l81": "oklch(81% 24.28% 148)", "l82": "oklch(82% 23.806% 148)", "l83": "oklch(83% 23.282% 148)", "l84": "oklch(84% 22.706% 148)", "l85": "oklch(85% 22.074% 148)", "l86": "oklch(86% 21.386% 148)", "l87": "oklch(87% 20.636% 148)", "l88": "oklch(88% 19.824% 148)", "l89": "oklch(89% 18.946% 148)", "l90": "oklch(90% 18% 148)", "l91": "oklch(91% 16.985% 148)", "l92": "oklch(92% 15.914% 148)", "l93": "oklch(93% 14.8% 148)", "l94": "oklch(94% 13.657% 148)", "l95": "oklch(95% 12.5% 148)", "l96": "oklch(96% 11.343% 148)", "l97": "oklch(97% 10.2% 148)", "l98": "oklch(98% 9.0862% 148)", "l99": "oklch(99% 8.0146% 148)", "l100": "oklch(100% 7% 148)"}, "blue": {"l0": "oklch(0% 5.3986% 262)", "l1": "oklch(1% 6.1201% 262)", "l2": "oklch(2% 6.8247% 262)", "l3": "oklch(3% 7.5137% 262)", "l4": "oklch(4% 8.1883% 262)", "l5": "oklch(5% 8.8497% 262)", "l6": "oklch(6% 9.499% 262)", "l7": "oklch(7% 10.137% 262)", "l8": "oklch(8% 10.766% 262)", "l9": "oklch(9% 11.387% 262)", "l10": "oklch(10% 12% 262)", "l11": "oklch(11% 12.607% 262)", "l12": "oklch(12% 13.21% 262)", "l13": "oklch(13% 13.808% 262)", "l14": "oklch(14% 14.405% 262)", "l15": "oklch(15% 15% 262)", "l16": "oklch(16% 15.595% 262)", "l17": "oklch(17% 16.192% 262)", "l18": "oklch(18% 16.79% 262)", "l19": "oklch(19% 17.393% 262)", "l20": "oklch(20% 18% 262)", "l21": "oklch(21% 18.613% 262)", "l22": "oklch(22% 19.23% 262)", "l23": "oklch(23% 19.851% 262)", "l24": "oklch(24% 20.473% 262)", "l25": "oklch(25% 21.095% 262)", "l26": "oklch(26% 21.716% 262)", "l27": "oklch(27% 22.335% 262)", "l28": "oklch(28% 22.949% 262)", "l29": "oklch(29% 23.558% 262)", "l30": "oklch(30% 24.16% 262)", "l31": "oklch(31% 24.753% 262)", "l32": "oklch(32% 25.337% 262)", "l33": "oklch(33% 25.909% 262)", "l34": "oklch(34% 26.468% 262)", "l35": "oklch(35% 27.014% 262)", "l36": "oklch(36% 27.543% 262)", "l37": "oklch(37% 28.055% 262)", "l38": "oklch(38% 28.549% 262)", "l39": "oklch(39% 29.023% 262)", "l40": "oklch(40% 29.475% 262)", "l41": "oklch(41% 29.905% 262)", "l42": "oklch(42% 30.31% 262)", "l43": "oklch(43% 30.689% 262)", "l44": "oklch(44% 31.041% 262)", "l45": "oklch(45% 31.364% 262)", "l46": "oklch(46% 31.658% 262)", "l47": "oklch(47% 31.919% 262)", "l48": "oklch(48% 32.148% 262)", "l49": "oklch(49% 32.342% 262)", "l50": "oklch(50% 32.5% 262)", "l51": "oklch(51% 32.621% 262)", "l52": "oklch(52% 32.705% 262)", "l53": "oklch(53% 32.75% 262)", "l54": "oklch(54% 32.758% 262)", "l55": "oklch(55% 32.728% 262)", "l56": "oklch(56% 32.66% 262)", "l57": "oklch(57% 32.553% 262)", "l58": "oklch(58% 32.407% 262)", "l59": "oklch(59% 32.223% 262)", "l60": "oklch(60% 32% 262)", "l61": "oklch(61% 31.738% 262)", "l62": "oklch(62% 31.438% 262)", "l63": "oklch(63% 31.1% 262)", "l64": "oklch(64% 30.726% 262)", "l65": "oklch(65% 30.316% 262)", "l66": "oklch(66% 29.871% 262)", "l67": "oklch(67% 29.392% 262)", "l68": "oklch(68% 28.881% 262)", "l69": "oklch(69% 28.337% 262)", "l70": "oklch(70% 27.761% 262)", "l71": "oklch(71% 27.156% 262)", "l72": "oklch(72% 26.52% 262)", "l73": "oklch(73% 25.856% 262)", "l74": "oklch(74% 25.164% 262)", "l75": "oklch(75% 24.445% 262)", "l76": "oklch(76% 23.699% 262)", "l77": "oklch(77% 22.929% 262)", "l78": "oklch(78% 22.134% 262)", "l79": "oklch(79% 21.315% 262)", "l80": "oklch(80% 20.474% 262)", "l81": "oklch(81% 19.611% 262)", "l82": "oklch(82% 18.726% 262)", "l83": "oklch(83% 17.822% 262)", "l84": "oklch(84% 16.898% 262)", "l85": "oklch(85% 15.956% 262)", "l86": "oklch(86% 14.997% 262)", "l87": "oklch(87% 14.02% 262)", "l88": "oklch(88% 13.028% 262)", "l89": "oklch(89% 12.021% 262)", "l90": "oklch(90% 11% 262)", "l91": "oklch(91% 9.9659% 262)", "l92": "oklch(92% 8.9212% 262)", "l93": "oklch(93% 7.8685% 262)", "l94": "oklch(94% 6.8106% 262)", "l95": "oklch(95% 5.75% 262)", "l96": "oklch(96% 4.6894% 262)", "l97": "oklch(97% 3.6315% 262)", "l98": "oklch(98% 2.5788% 262)", "l99": "oklch(99% 1.5341% 262)", "l100": "oklch(100% 0.5% 262)"}} \ No newline at end of file diff --git a/notebooks/palettes/monobiome-v111.toml b/notebooks/palettes/monobiome-v111.toml new file mode 100644 index 0000000..2bee7f2 --- /dev/null +++ b/notebooks/palettes/monobiome-v111.toml @@ -0,0 +1,1132 @@ +[alpine] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000000" +l6 = "#010101" +l7 = "#010101" +l8 = "#020202" +l9 = "#020202" +l10 = "#030303" +l11 = "#040404" +l12 = "#060606" +l13 = "#070707" +l14 = "#090909" +l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" +l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" +l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" +l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" +l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" +l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" +l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" +l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" +l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" +l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" +l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" +l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" +l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" +l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" +l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" +l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" +l95 = "#eeeeee" +l96 = "#f2f2f2" +l97 = "#f5f5f5" +l98 = "#f8f8f8" +l99 = "#fcfcfc" +l100 = "#ffffff" + +[badlands] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#010000" +l5 = "#010000" +l6 = "#020000" +l7 = "#020101" +l8 = "#030101" +l9 = "#040202" +l10 = "#060302" +l11 = "#070303" +l12 = "#090504" +l13 = "#0b0605" +l14 = "#0d0807" +l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" +l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" +l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" +l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" +l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" +l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" +l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" +l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" +l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" +l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" +l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" +l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" +l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" +l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" +l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" +l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" +l95 = "#f6ecea" +l96 = "#f9efee" +l97 = "#fcf3f1" +l98 = "#fff6f4" +l99 = "#fff9f8" +l100 = "#fffdfc" + +[chaparral] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#010000" +l5 = "#010000" +l6 = "#010100" +l7 = "#020100" +l8 = "#030101" +l9 = "#040201" +l10 = "#050301" +l11 = "#070402" +l12 = "#080503" +l13 = "#0a0704" +l14 = "#0c0805" +l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" +l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" +l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" +l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" +l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" +l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" +l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" +l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" +l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" +l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" +l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" +l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" +l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" +l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" +l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" +l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" +l95 = "#f4ede7" +l96 = "#f7f0ea" +l97 = "#fbf4ee" +l98 = "#fef7f1" +l99 = "#fffaf4" +l100 = "#fffefa" + +[savanna] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#010000" +l6 = "#010100" +l7 = "#010100" +l8 = "#020200" +l9 = "#030301" +l10 = "#040301" +l11 = "#050502" +l12 = "#060603" +l13 = "#080704" +l14 = "#0a0905" +l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" +l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" +l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" +l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" +l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" +l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" +l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" +l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" +l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" +l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" +l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" +l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" +l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" +l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" +l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" +l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" +l95 = "#efefe7" +l96 = "#f3f2ea" +l97 = "#f6f6ed" +l98 = "#f9f9f1" +l99 = "#fdfcf4" +l100 = "#ffffff" + +[grassland] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000100" +l6 = "#000100" +l7 = "#000101" +l8 = "#010201" +l9 = "#010302" +l10 = "#020402" +l11 = "#030503" +l12 = "#040704" +l13 = "#050805" +l14 = "#060a07" +l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" +l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" +l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" +l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" +l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" +l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" +l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" +l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" +l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" +l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" +l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" +l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" +l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" +l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" +l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" +l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" +l95 = "#eaf1ea" +l96 = "#edf4ee" +l97 = "#f0f7f1" +l98 = "#f4fbf4" +l99 = "#f7fef8" +l100 = "#ffffff" + +[tundra] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000001" +l5 = "#000001" +l6 = "#000102" +l7 = "#010103" +l8 = "#010203" +l9 = "#020205" +l10 = "#020306" +l11 = "#030408" +l12 = "#040609" +l13 = "#05070c" +l14 = "#07090e" +l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" +l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" +l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" +l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" +l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" +l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" +l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" +l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" +l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" +l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" +l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" +l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" +l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" +l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" +l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" +l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" +l95 = "#eaeff6" +l96 = "#eef2f9" +l97 = "#f1f5fd" +l98 = "#f4f9ff" +l99 = "#f8fcff" +l100 = "#ffffff" + +[red] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#010000" +l5 = "#020000" +l6 = "#030000" +l7 = "#050000" +l8 = "#070000" +l9 = "#0a0000" +l10 = "#0d0000" +l11 = "#110000" +l12 = "#140000" +l13 = "#170000" +l14 = "#1b0000" +l15 = "#1e0100" +l16 = "#210101" +l17 = "#250101" +l18 = "#290201" +l19 = "#2c0202" +l20 = "#300302" +l21 = "#340402" +l22 = "#380403" +l23 = "#3c0503" +l24 = "#400503" +l25 = "#440604" +l26 = "#480704" +l27 = "#4c0705" +l28 = "#510805" +l29 = "#550905" +l30 = "#590906" +l31 = "#5e0a06" +l32 = "#620b07" +l33 = "#670b07" +l34 = "#6b0c08" +l35 = "#700d08" +l36 = "#740d09" +l37 = "#790e09" +l38 = "#7e0f0a" +l39 = "#82100b" +l40 = "#87110c" +l41 = "#8b120d" +l42 = "#90130e" +l43 = "#95150f" +l44 = "#991610" +l45 = "#9e1811" +l46 = "#a21913" +l47 = "#a71b14" +l48 = "#ab1d16" +l49 = "#b01f17" +l50 = "#b42219" +l51 = "#b9241b" +l52 = "#bd271d" +l53 = "#c12920" +l54 = "#c52c22" +l55 = "#c92f25" +l56 = "#cd3327" +l57 = "#d1362a" +l58 = "#d53a2d" +l59 = "#d83e31" +l60 = "#dc4234" +l61 = "#df4638" +l62 = "#e24a3c" +l63 = "#e54e40" +l64 = "#e75344" +l65 = "#ea5848" +l66 = "#ec5c4d" +l67 = "#ee6151" +l68 = "#f06656" +l69 = "#f26b5b" +l70 = "#f47060" +l71 = "#f57565" +l72 = "#f77a6a" +l73 = "#f87f6f" +l74 = "#f98474" +l75 = "#fa8979" +l76 = "#fb8e7e" +l77 = "#fc9384" +l78 = "#fd9889" +l79 = "#fd9d8e" +l80 = "#fea294" +l81 = "#fea699" +l82 = "#ffab9f" +l83 = "#ffb0a4" +l84 = "#ffb5aa" +l85 = "#ffbaaf" +l86 = "#ffbfb5" +l87 = "#ffc4ba" +l88 = "#ffc8c0" +l89 = "#ffcdc5" +l90 = "#ffd2ca" +l91 = "#ffd7d0" +l92 = "#ffdbd5" +l93 = "#ffe0db" +l94 = "#ffe4e0" +l95 = "#fee9e5" +l96 = "#feeeeb" +l97 = "#fef2f0" +l98 = "#fdf7f6" +l99 = "#fdfbfb" +l100 = "#ffffff" + +[orange] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#010000" +l6 = "#020000" +l7 = "#030100" +l8 = "#040100" +l9 = "#050200" +l10 = "#070200" +l11 = "#090300" +l12 = "#0c0400" +l13 = "#0f0500" +l14 = "#110601" +l15 = "#140801" +l16 = "#170a01" +l17 = "#190c02" +l18 = "#1c0e02" +l19 = "#1f1003" +l20 = "#221203" +l21 = "#251404" +l22 = "#281604" +l23 = "#2b1805" +l24 = "#2f1a05" +l25 = "#321c06" +l26 = "#351e06" +l27 = "#392007" +l28 = "#3c2207" +l29 = "#3f2407" +l30 = "#432607" +l31 = "#472807" +l32 = "#4a2a07" +l33 = "#4e2c07" +l34 = "#522e07" +l35 = "#553007" +l36 = "#593206" +l37 = "#5d3506" +l38 = "#613705" +l39 = "#653905" +l40 = "#693b04" +l41 = "#6d3d03" +l42 = "#713f02" +l43 = "#754102" +l44 = "#794401" +l45 = "#7d4600" +l46 = "#814800" +l47 = "#854a00" +l48 = "#894d00" +l49 = "#8d4f00" +l50 = "#915100" +l51 = "#945400" +l52 = "#985600" +l53 = "#9c5900" +l54 = "#a05b00" +l55 = "#a45e00" +l56 = "#a86000" +l57 = "#ac6302" +l58 = "#b06605" +l59 = "#b46808" +l60 = "#b76b0c" +l61 = "#bb6e10" +l62 = "#bf7114" +l63 = "#c27318" +l64 = "#c6761c" +l65 = "#c97920" +l66 = "#cd7c25" +l67 = "#d08029" +l68 = "#d3832e" +l69 = "#d68632" +l70 = "#d98937" +l71 = "#dc8d3c" +l72 = "#df9041" +l73 = "#e29346" +l74 = "#e4974c" +l75 = "#e79b51" +l76 = "#e99e57" +l77 = "#eba25d" +l78 = "#eea663" +l79 = "#f0a969" +l80 = "#f2ad6f" +l81 = "#f3b175" +l82 = "#f5b57b" +l83 = "#f7b982" +l84 = "#f8bd89" +l85 = "#f9c18f" +l86 = "#fac596" +l87 = "#fbc99d" +l88 = "#fccda4" +l89 = "#fdd1ac" +l90 = "#fed5b3" +l91 = "#fedabb" +l92 = "#fedec2" +l93 = "#ffe2ca" +l94 = "#ffe6d1" +l95 = "#ffead9" +l96 = "#ffefe1" +l97 = "#fff3e9" +l98 = "#fff7f0" +l99 = "#fffbf8" +l100 = "#ffffff" + +[yellow] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#010000" +l6 = "#010100" +l7 = "#010100" +l8 = "#020200" +l9 = "#030300" +l10 = "#040301" +l11 = "#050501" +l12 = "#070601" +l13 = "#080802" +l14 = "#0a0903" +l15 = "#0c0c03" +l16 = "#0f0e04" +l17 = "#111005" +l18 = "#131207" +l19 = "#151408" +l20 = "#181709" +l21 = "#1a190b" +l22 = "#1c1b0d" +l23 = "#1f1e0e" +l24 = "#212010" +l25 = "#242211" +l26 = "#262513" +l27 = "#292714" +l28 = "#2b2a16" +l29 = "#2e2c17" +l30 = "#312f19" +l31 = "#33311a" +l32 = "#36341c" +l33 = "#39361d" +l34 = "#3b391e" +l35 = "#3e3c20" +l36 = "#413e21" +l37 = "#444122" +l38 = "#474424" +l39 = "#494625" +l40 = "#4c4926" +l41 = "#4f4c28" +l42 = "#524f29" +l43 = "#55512b" +l44 = "#58542c" +l45 = "#5b572d" +l46 = "#5e5a2f" +l47 = "#615d30" +l48 = "#646032" +l49 = "#676233" +l50 = "#6a6535" +l51 = "#6d6836" +l52 = "#706b38" +l53 = "#736e39" +l54 = "#76713b" +l55 = "#79743d" +l56 = "#7c773f" +l57 = "#7f7a40" +l58 = "#827d42" +l59 = "#858044" +l60 = "#888346" +l61 = "#8b8648" +l62 = "#8e894a" +l63 = "#928c4d" +l64 = "#958f4f" +l65 = "#989251" +l66 = "#9b9554" +l67 = "#9e9856" +l68 = "#a19b59" +l69 = "#a49e5c" +l70 = "#a7a15f" +l71 = "#aaa462" +l72 = "#ada865" +l73 = "#b1ab68" +l74 = "#b4ae6c" +l75 = "#b7b16f" +l76 = "#bab473" +l77 = "#bdb777" +l78 = "#c0ba7b" +l79 = "#c3be7f" +l80 = "#c6c183" +l81 = "#c9c487" +l82 = "#ccc78c" +l83 = "#cfca90" +l84 = "#d2ce95" +l85 = "#d5d19a" +l86 = "#d8d49f" +l87 = "#dbd7a4" +l88 = "#dedaa9" +l89 = "#e1ddaf" +l90 = "#e4e1b4" +l91 = "#e7e4ba" +l92 = "#eae7c0" +l93 = "#edeac6" +l94 = "#f0edcc" +l95 = "#f2f0d2" +l96 = "#f5f4d8" +l97 = "#f8f7de" +l98 = "#fbfae4" +l99 = "#fefdea" +l100 = "#ffffff" + +[green] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000100" +l6 = "#000100" +l7 = "#000200" +l8 = "#000300" +l9 = "#000400" +l10 = "#000500" +l11 = "#000701" +l12 = "#000901" +l13 = "#000b02" +l14 = "#000d02" +l15 = "#010f03" +l16 = "#011204" +l17 = "#021405" +l18 = "#031706" +l19 = "#031907" +l20 = "#041c09" +l21 = "#051e0a" +l22 = "#06210c" +l23 = "#08230e" +l24 = "#09260f" +l25 = "#0b2911" +l26 = "#0c2b13" +l27 = "#0e2e15" +l28 = "#0f3116" +l29 = "#113418" +l30 = "#12371a" +l31 = "#14391c" +l32 = "#163c1d" +l33 = "#173f1f" +l34 = "#194221" +l35 = "#1a4523" +l36 = "#1c4825" +l37 = "#1e4b27" +l38 = "#1f4e29" +l39 = "#21512b" +l40 = "#23542c" +l41 = "#25572e" +l42 = "#275a30" +l43 = "#285d32" +l44 = "#2a6035" +l45 = "#2c6337" +l46 = "#2e6639" +l47 = "#30693b" +l48 = "#326c3d" +l49 = "#346f3f" +l50 = "#367242" +l51 = "#397644" +l52 = "#3b7946" +l53 = "#3d7c49" +l54 = "#407f4b" +l55 = "#42824d" +l56 = "#458550" +l57 = "#478852" +l58 = "#4a8b55" +l59 = "#4c8f58" +l60 = "#4f925a" +l61 = "#52955d" +l62 = "#559860" +l63 = "#589b63" +l64 = "#5b9e66" +l65 = "#5ea168" +l66 = "#61a46b" +l67 = "#64a86e" +l68 = "#67ab72" +l69 = "#6aae75" +l70 = "#6eb178" +l71 = "#71b47b" +l72 = "#74b77e" +l73 = "#78ba81" +l74 = "#7bbd85" +l75 = "#7fc088" +l76 = "#82c48b" +l77 = "#86c78f" +l78 = "#8aca92" +l79 = "#8ecd96" +l80 = "#91d09a" +l81 = "#96d39e" +l82 = "#9ad6a1" +l83 = "#9ed8a5" +l84 = "#a2dba9" +l85 = "#a7dead" +l86 = "#abe1b2" +l87 = "#b0e4b6" +l88 = "#b5e7ba" +l89 = "#b9e9bf" +l90 = "#beecc4" +l91 = "#c4eec8" +l92 = "#c9f1cd" +l93 = "#cef3d2" +l94 = "#d4f6d7" +l95 = "#d9f8dc" +l96 = "#defbe1" +l97 = "#e4fde6" +l98 = "#e9ffeb" +l99 = "#eefff0" +l100 = "#ffffff" + +[blue] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000002" +l4 = "#000003" +l5 = "#000005" +l6 = "#000007" +l7 = "#000009" +l8 = "#00010d" +l9 = "#000110" +l10 = "#000213" +l11 = "#000316" +l12 = "#00041a" +l13 = "#00051d" +l14 = "#010720" +l15 = "#010924" +l16 = "#010b27" +l17 = "#020d2b" +l18 = "#020f2f" +l19 = "#031132" +l20 = "#041336" +l21 = "#04153a" +l22 = "#05183e" +l23 = "#061a41" +l24 = "#081c45" +l25 = "#091f49" +l26 = "#0a214d" +l27 = "#0c2351" +l28 = "#0d2655" +l29 = "#0f2859" +l30 = "#102a5d" +l31 = "#122d61" +l32 = "#142f66" +l33 = "#15326a" +l34 = "#17346e" +l35 = "#193772" +l36 = "#1b3a76" +l37 = "#1c3c7a" +l38 = "#1e3f7e" +l39 = "#204182" +l40 = "#224486" +l41 = "#24478a" +l42 = "#26498e" +l43 = "#284c92" +l44 = "#2a4f96" +l45 = "#2c529a" +l46 = "#2f559e" +l47 = "#3157a2" +l48 = "#335aa5" +l49 = "#365da9" +l50 = "#3860ac" +l51 = "#3b63b0" +l52 = "#3d66b3" +l53 = "#4069b7" +l54 = "#436cba" +l55 = "#466fbd" +l56 = "#4972c0" +l57 = "#4b75c3" +l58 = "#4f78c6" +l59 = "#527bc9" +l60 = "#557ecc" +l61 = "#5881cf" +l62 = "#5b85d2" +l63 = "#5f88d4" +l64 = "#628bd7" +l65 = "#668ed9" +l66 = "#6991db" +l67 = "#6d94dd" +l68 = "#7198e0" +l69 = "#749be2" +l70 = "#789ee4" +l71 = "#7ca1e6" +l72 = "#80a5e7" +l73 = "#84a8e9" +l74 = "#88abeb" +l75 = "#8caeec" +l76 = "#90b1ee" +l77 = "#94b5ef" +l78 = "#99b8f1" +l79 = "#9dbbf2" +l80 = "#a1bef3" +l81 = "#a5c2f4" +l82 = "#aac5f5" +l83 = "#aec8f7" +l84 = "#b3cbf8" +l85 = "#b7cff8" +l86 = "#bcd2f9" +l87 = "#c0d5fa" +l88 = "#c5d8fb" +l89 = "#cadcfb" +l90 = "#cedffc" +l91 = "#d3e2fd" +l92 = "#d8e5fd" +l93 = "#dde9fe" +l94 = "#e1ecfe" +l95 = "#e6efff" +l96 = "#ebf2ff" +l97 = "#f0f5ff" +l98 = "#f5f9ff" +l99 = "#f9fcff" +l100 = "#ffffff" diff --git a/notebooks/palettes/monobiome-vMCL-oklch.json b/notebooks/palettes/monobiome-vMCL-oklch.json new file mode 100644 index 0000000..f74ec8a --- /dev/null +++ b/notebooks/palettes/monobiome-vMCL-oklch.json @@ -0,0 +1 @@ +{"alpine": {"l15": "oklch(15% 0% 0)", "l16": "oklch(16% 0% 0)", "l17": "oklch(17% 0% 0)", "l18": "oklch(18% 0% 0)", "l19": "oklch(19% 0% 0)", "l20": "oklch(20% 0% 0)", "l21": "oklch(21% 0% 0)", "l22": "oklch(22% 0% 0)", "l23": "oklch(23% 0% 0)", "l24": "oklch(24% 0% 0)", "l25": "oklch(25% 0% 0)", "l26": "oklch(26% 0% 0)", "l27": "oklch(27% 0% 0)", "l28": "oklch(28% 0% 0)", "l29": "oklch(29% 0% 0)", "l30": "oklch(30% 0% 0)", "l31": "oklch(31% 0% 0)", "l32": "oklch(32% 0% 0)", "l33": "oklch(33% 0% 0)", "l34": "oklch(34% 0% 0)", "l35": "oklch(35% 0% 0)", "l36": "oklch(36% 0% 0)", "l37": "oklch(37% 0% 0)", "l38": "oklch(38% 0% 0)", "l39": "oklch(39% 0% 0)", "l40": "oklch(40% 0% 0)", "l41": "oklch(41% 0% 0)", "l42": "oklch(42% 0% 0)", "l43": "oklch(43% 0% 0)", "l44": "oklch(44% 0% 0)", "l45": "oklch(45% 0% 0)", "l46": "oklch(46% 0% 0)", "l47": "oklch(47% 0% 0)", "l48": "oklch(48% 0% 0)", "l49": "oklch(49% 0% 0)", "l50": "oklch(50% 0% 0)", "l51": "oklch(51% 0% 0)", "l52": "oklch(52% 0% 0)", "l53": "oklch(53% 0% 0)", "l54": "oklch(54% 0% 0)", "l55": "oklch(55% 0% 0)", "l56": "oklch(56% 0% 0)", "l57": "oklch(57% 0% 0)", "l58": "oklch(58% 0% 0)", "l59": "oklch(59% 0% 0)", "l60": "oklch(60% 0% 0)", "l61": "oklch(61% 0% 0)", "l62": "oklch(62% 0% 0)", "l63": "oklch(63% 0% 0)", "l64": "oklch(64% 0% 0)", "l65": "oklch(65% 0% 0)", "l66": "oklch(66% 0% 0)", "l67": "oklch(67% 0% 0)", "l68": "oklch(68% 0% 0)", "l69": "oklch(69% 0% 0)", "l70": "oklch(70% 0% 0)", "l71": "oklch(71% 0% 0)", "l72": "oklch(72% 0% 0)", "l73": "oklch(73% 0% 0)", "l74": "oklch(74% 0% 0)", "l75": "oklch(75% 0% 0)", "l76": "oklch(76% 0% 0)", "l77": "oklch(77% 0% 0)", "l78": "oklch(78% 0% 0)", "l79": "oklch(79% 0% 0)", "l80": "oklch(80% 0% 0)", "l81": "oklch(81% 0% 0)", "l82": "oklch(82% 0% 0)", "l83": "oklch(83% 0% 0)", "l84": "oklch(84% 0% 0)", "l85": "oklch(85% 0% 0)", "l86": "oklch(86% 0% 0)", "l87": "oklch(87% 0% 0)", "l88": "oklch(88% 0% 0)", "l89": "oklch(89% 0% 0)", "l90": "oklch(90% 0% 0)", "l91": "oklch(91% 0% 0)", "l92": "oklch(92% 0% 0)", "l93": "oklch(93% 0% 0)", "l94": "oklch(94% 0% 0)", "l95": "oklch(95% 0% 0)"}, "badlands": {"l15": "oklch(15% 2.75% 29)", "l16": "oklch(16% 2.75% 29)", "l17": "oklch(17% 2.75% 29)", "l18": "oklch(18% 2.75% 29)", "l19": "oklch(19% 2.75% 29)", "l20": "oklch(20% 2.75% 29)", "l21": "oklch(21% 2.75% 29)", "l22": "oklch(22% 2.75% 29)", "l23": "oklch(23% 2.75% 29)", "l24": "oklch(24% 2.75% 29)", "l25": "oklch(25% 2.75% 29)", "l26": "oklch(26% 2.75% 29)", "l27": "oklch(27% 2.75% 29)", "l28": "oklch(28% 2.75% 29)", "l29": "oklch(29% 2.75% 29)", "l30": "oklch(30% 2.75% 29)", "l31": "oklch(31% 2.75% 29)", "l32": "oklch(32% 2.75% 29)", "l33": "oklch(33% 2.75% 29)", "l34": "oklch(34% 2.75% 29)", "l35": "oklch(35% 2.75% 29)", "l36": "oklch(36% 2.75% 29)", "l37": "oklch(37% 2.75% 29)", "l38": "oklch(38% 2.75% 29)", "l39": "oklch(39% 2.75% 29)", "l40": "oklch(40% 2.75% 29)", "l41": "oklch(41% 2.75% 29)", "l42": "oklch(42% 2.75% 29)", "l43": "oklch(43% 2.75% 29)", "l44": "oklch(44% 2.75% 29)", "l45": "oklch(45% 2.75% 29)", "l46": "oklch(46% 2.75% 29)", "l47": "oklch(47% 2.75% 29)", "l48": "oklch(48% 2.75% 29)", "l49": "oklch(49% 2.75% 29)", "l50": "oklch(50% 2.75% 29)", "l51": "oklch(51% 2.75% 29)", "l52": "oklch(52% 2.75% 29)", "l53": "oklch(53% 2.75% 29)", "l54": "oklch(54% 2.75% 29)", "l55": "oklch(55% 2.75% 29)", "l56": "oklch(56% 2.75% 29)", "l57": "oklch(57% 2.75% 29)", "l58": "oklch(58% 2.75% 29)", "l59": "oklch(59% 2.75% 29)", "l60": "oklch(60% 2.75% 29)", "l61": "oklch(61% 2.75% 29)", "l62": "oklch(62% 2.75% 29)", "l63": "oklch(63% 2.75% 29)", "l64": "oklch(64% 2.75% 29)", "l65": "oklch(65% 2.75% 29)", "l66": "oklch(66% 2.75% 29)", "l67": "oklch(67% 2.75% 29)", "l68": "oklch(68% 2.75% 29)", "l69": "oklch(69% 2.75% 29)", "l70": "oklch(70% 2.75% 29)", "l71": "oklch(71% 2.75% 29)", "l72": "oklch(72% 2.75% 29)", "l73": "oklch(73% 2.75% 29)", "l74": "oklch(74% 2.75% 29)", "l75": "oklch(75% 2.75% 29)", "l76": "oklch(76% 2.75% 29)", "l77": "oklch(77% 2.75% 29)", "l78": "oklch(78% 2.75% 29)", "l79": "oklch(79% 2.75% 29)", "l80": "oklch(80% 2.75% 29)", "l81": "oklch(81% 2.75% 29)", "l82": "oklch(82% 2.75% 29)", "l83": "oklch(83% 2.75% 29)", "l84": "oklch(84% 2.75% 29)", "l85": "oklch(85% 2.75% 29)", "l86": "oklch(86% 2.75% 29)", "l87": "oklch(87% 2.75% 29)", "l88": "oklch(88% 2.75% 29)", "l89": "oklch(89% 2.75% 29)", "l90": "oklch(90% 2.75% 29)", "l91": "oklch(91% 2.75% 29)", "l92": "oklch(92% 2.75% 29)", "l93": "oklch(93% 2.75% 29)", "l94": "oklch(94% 2.75% 29)", "l95": "oklch(95% 2.75% 29)"}, "chaparral": {"l15": "oklch(15% 2.75% 62.5)", "l16": "oklch(16% 2.75% 62.5)", "l17": "oklch(17% 2.75% 62.5)", "l18": "oklch(18% 2.75% 62.5)", "l19": "oklch(19% 2.75% 62.5)", "l20": "oklch(20% 2.75% 62.5)", "l21": "oklch(21% 2.75% 62.5)", "l22": "oklch(22% 2.75% 62.5)", "l23": "oklch(23% 2.75% 62.5)", "l24": "oklch(24% 2.75% 62.5)", "l25": "oklch(25% 2.75% 62.5)", "l26": "oklch(26% 2.75% 62.5)", "l27": "oklch(27% 2.75% 62.5)", "l28": "oklch(28% 2.75% 62.5)", "l29": "oklch(29% 2.75% 62.5)", "l30": "oklch(30% 2.75% 62.5)", "l31": "oklch(31% 2.75% 62.5)", "l32": "oklch(32% 2.75% 62.5)", "l33": "oklch(33% 2.75% 62.5)", "l34": "oklch(34% 2.75% 62.5)", "l35": "oklch(35% 2.75% 62.5)", "l36": "oklch(36% 2.75% 62.5)", "l37": "oklch(37% 2.75% 62.5)", "l38": "oklch(38% 2.75% 62.5)", "l39": "oklch(39% 2.75% 62.5)", "l40": "oklch(40% 2.75% 62.5)", "l41": "oklch(41% 2.75% 62.5)", "l42": "oklch(42% 2.75% 62.5)", "l43": "oklch(43% 2.75% 62.5)", "l44": "oklch(44% 2.75% 62.5)", "l45": "oklch(45% 2.75% 62.5)", "l46": "oklch(46% 2.75% 62.5)", "l47": "oklch(47% 2.75% 62.5)", "l48": "oklch(48% 2.75% 62.5)", "l49": "oklch(49% 2.75% 62.5)", "l50": "oklch(50% 2.75% 62.5)", "l51": "oklch(51% 2.75% 62.5)", "l52": "oklch(52% 2.75% 62.5)", "l53": "oklch(53% 2.75% 62.5)", "l54": "oklch(54% 2.75% 62.5)", "l55": "oklch(55% 2.75% 62.5)", "l56": "oklch(56% 2.75% 62.5)", "l57": "oklch(57% 2.75% 62.5)", "l58": "oklch(58% 2.75% 62.5)", "l59": "oklch(59% 2.75% 62.5)", "l60": "oklch(60% 2.75% 62.5)", "l61": "oklch(61% 2.75% 62.5)", "l62": "oklch(62% 2.75% 62.5)", "l63": "oklch(63% 2.75% 62.5)", "l64": "oklch(64% 2.75% 62.5)", "l65": "oklch(65% 2.75% 62.5)", "l66": "oklch(66% 2.75% 62.5)", "l67": "oklch(67% 2.75% 62.5)", "l68": "oklch(68% 2.75% 62.5)", "l69": "oklch(69% 2.75% 62.5)", "l70": "oklch(70% 2.75% 62.5)", "l71": "oklch(71% 2.75% 62.5)", "l72": "oklch(72% 2.75% 62.5)", "l73": "oklch(73% 2.75% 62.5)", "l74": "oklch(74% 2.75% 62.5)", "l75": "oklch(75% 2.75% 62.5)", "l76": "oklch(76% 2.75% 62.5)", "l77": "oklch(77% 2.75% 62.5)", "l78": "oklch(78% 2.75% 62.5)", "l79": "oklch(79% 2.75% 62.5)", "l80": "oklch(80% 2.75% 62.5)", "l81": "oklch(81% 2.75% 62.5)", "l82": "oklch(82% 2.75% 62.5)", "l83": "oklch(83% 2.75% 62.5)", "l84": "oklch(84% 2.75% 62.5)", "l85": "oklch(85% 2.75% 62.5)", "l86": "oklch(86% 2.75% 62.5)", "l87": "oklch(87% 2.75% 62.5)", "l88": "oklch(88% 2.75% 62.5)", "l89": "oklch(89% 2.75% 62.5)", "l90": "oklch(90% 2.75% 62.5)", "l91": "oklch(91% 2.75% 62.5)", "l92": "oklch(92% 2.75% 62.5)", "l93": "oklch(93% 2.75% 62.5)", "l94": "oklch(94% 2.75% 62.5)", "l95": "oklch(95% 2.75% 62.5)"}, "savanna": {"l15": "oklch(15% 2.75% 104)", "l16": "oklch(16% 2.75% 104)", "l17": "oklch(17% 2.75% 104)", "l18": "oklch(18% 2.75% 104)", "l19": "oklch(19% 2.75% 104)", "l20": "oklch(20% 2.75% 104)", "l21": "oklch(21% 2.75% 104)", "l22": "oklch(22% 2.75% 104)", "l23": "oklch(23% 2.75% 104)", "l24": "oklch(24% 2.75% 104)", "l25": "oklch(25% 2.75% 104)", "l26": "oklch(26% 2.75% 104)", "l27": "oklch(27% 2.75% 104)", "l28": "oklch(28% 2.75% 104)", "l29": "oklch(29% 2.75% 104)", "l30": "oklch(30% 2.75% 104)", "l31": "oklch(31% 2.75% 104)", "l32": "oklch(32% 2.75% 104)", "l33": "oklch(33% 2.75% 104)", "l34": "oklch(34% 2.75% 104)", "l35": "oklch(35% 2.75% 104)", "l36": "oklch(36% 2.75% 104)", "l37": "oklch(37% 2.75% 104)", "l38": "oklch(38% 2.75% 104)", "l39": "oklch(39% 2.75% 104)", "l40": "oklch(40% 2.75% 104)", "l41": "oklch(41% 2.75% 104)", "l42": "oklch(42% 2.75% 104)", "l43": "oklch(43% 2.75% 104)", "l44": "oklch(44% 2.75% 104)", "l45": "oklch(45% 2.75% 104)", "l46": "oklch(46% 2.75% 104)", "l47": "oklch(47% 2.75% 104)", "l48": "oklch(48% 2.75% 104)", "l49": "oklch(49% 2.75% 104)", "l50": "oklch(50% 2.75% 104)", "l51": "oklch(51% 2.75% 104)", "l52": "oklch(52% 2.75% 104)", "l53": "oklch(53% 2.75% 104)", "l54": "oklch(54% 2.75% 104)", "l55": "oklch(55% 2.75% 104)", "l56": "oklch(56% 2.75% 104)", "l57": "oklch(57% 2.75% 104)", "l58": "oklch(58% 2.75% 104)", "l59": "oklch(59% 2.75% 104)", "l60": "oklch(60% 2.75% 104)", "l61": "oklch(61% 2.75% 104)", "l62": "oklch(62% 2.75% 104)", "l63": "oklch(63% 2.75% 104)", "l64": "oklch(64% 2.75% 104)", "l65": "oklch(65% 2.75% 104)", "l66": "oklch(66% 2.75% 104)", "l67": "oklch(67% 2.75% 104)", "l68": "oklch(68% 2.75% 104)", "l69": "oklch(69% 2.75% 104)", "l70": "oklch(70% 2.75% 104)", "l71": "oklch(71% 2.75% 104)", "l72": "oklch(72% 2.75% 104)", "l73": "oklch(73% 2.75% 104)", "l74": "oklch(74% 2.75% 104)", "l75": "oklch(75% 2.75% 104)", "l76": "oklch(76% 2.75% 104)", "l77": "oklch(77% 2.75% 104)", "l78": "oklch(78% 2.75% 104)", "l79": "oklch(79% 2.75% 104)", "l80": "oklch(80% 2.75% 104)", "l81": "oklch(81% 2.75% 104)", "l82": "oklch(82% 2.75% 104)", "l83": "oklch(83% 2.75% 104)", "l84": "oklch(84% 2.75% 104)", "l85": "oklch(85% 2.75% 104)", "l86": "oklch(86% 2.75% 104)", "l87": "oklch(87% 2.75% 104)", "l88": "oklch(88% 2.75% 104)", "l89": "oklch(89% 2.75% 104)", "l90": "oklch(90% 2.75% 104)", "l91": "oklch(91% 2.75% 104)", "l92": "oklch(92% 2.75% 104)", "l93": "oklch(93% 2.75% 104)", "l94": "oklch(94% 2.75% 104)", "l95": "oklch(95% 2.75% 104)"}, "grassland": {"l15": "oklch(15% 2.75% 148)", "l16": "oklch(16% 2.75% 148)", "l17": "oklch(17% 2.75% 148)", "l18": "oklch(18% 2.75% 148)", "l19": "oklch(19% 2.75% 148)", "l20": "oklch(20% 2.75% 148)", "l21": "oklch(21% 2.75% 148)", "l22": "oklch(22% 2.75% 148)", "l23": "oklch(23% 2.75% 148)", "l24": "oklch(24% 2.75% 148)", "l25": "oklch(25% 2.75% 148)", "l26": "oklch(26% 2.75% 148)", "l27": "oklch(27% 2.75% 148)", "l28": "oklch(28% 2.75% 148)", "l29": "oklch(29% 2.75% 148)", "l30": "oklch(30% 2.75% 148)", "l31": "oklch(31% 2.75% 148)", "l32": "oklch(32% 2.75% 148)", "l33": "oklch(33% 2.75% 148)", "l34": "oklch(34% 2.75% 148)", "l35": "oklch(35% 2.75% 148)", "l36": "oklch(36% 2.75% 148)", "l37": "oklch(37% 2.75% 148)", "l38": "oklch(38% 2.75% 148)", "l39": "oklch(39% 2.75% 148)", "l40": "oklch(40% 2.75% 148)", "l41": "oklch(41% 2.75% 148)", "l42": "oklch(42% 2.75% 148)", "l43": "oklch(43% 2.75% 148)", "l44": "oklch(44% 2.75% 148)", "l45": "oklch(45% 2.75% 148)", "l46": "oklch(46% 2.75% 148)", "l47": "oklch(47% 2.75% 148)", "l48": "oklch(48% 2.75% 148)", "l49": "oklch(49% 2.75% 148)", "l50": "oklch(50% 2.75% 148)", "l51": "oklch(51% 2.75% 148)", "l52": "oklch(52% 2.75% 148)", "l53": "oklch(53% 2.75% 148)", "l54": "oklch(54% 2.75% 148)", "l55": "oklch(55% 2.75% 148)", "l56": "oklch(56% 2.75% 148)", "l57": "oklch(57% 2.75% 148)", "l58": "oklch(58% 2.75% 148)", "l59": "oklch(59% 2.75% 148)", "l60": "oklch(60% 2.75% 148)", "l61": "oklch(61% 2.75% 148)", "l62": "oklch(62% 2.75% 148)", "l63": "oklch(63% 2.75% 148)", "l64": "oklch(64% 2.75% 148)", "l65": "oklch(65% 2.75% 148)", "l66": "oklch(66% 2.75% 148)", "l67": "oklch(67% 2.75% 148)", "l68": "oklch(68% 2.75% 148)", "l69": "oklch(69% 2.75% 148)", "l70": "oklch(70% 2.75% 148)", "l71": "oklch(71% 2.75% 148)", "l72": "oklch(72% 2.75% 148)", "l73": "oklch(73% 2.75% 148)", "l74": "oklch(74% 2.75% 148)", "l75": "oklch(75% 2.75% 148)", "l76": "oklch(76% 2.75% 148)", "l77": "oklch(77% 2.75% 148)", "l78": "oklch(78% 2.75% 148)", "l79": "oklch(79% 2.75% 148)", "l80": "oklch(80% 2.75% 148)", "l81": "oklch(81% 2.75% 148)", "l82": "oklch(82% 2.75% 148)", "l83": "oklch(83% 2.75% 148)", "l84": "oklch(84% 2.75% 148)", "l85": "oklch(85% 2.75% 148)", "l86": "oklch(86% 2.75% 148)", "l87": "oklch(87% 2.75% 148)", "l88": "oklch(88% 2.75% 148)", "l89": "oklch(89% 2.75% 148)", "l90": "oklch(90% 2.75% 148)", "l91": "oklch(91% 2.75% 148)", "l92": "oklch(92% 2.75% 148)", "l93": "oklch(93% 2.75% 148)", "l94": "oklch(94% 2.75% 148)", "l95": "oklch(95% 2.75% 148)"}, "tundra": {"l15": "oklch(15% 2.75% 262)", "l16": "oklch(16% 2.75% 262)", "l17": "oklch(17% 2.75% 262)", "l18": "oklch(18% 2.75% 262)", "l19": "oklch(19% 2.75% 262)", "l20": "oklch(20% 2.75% 262)", "l21": "oklch(21% 2.75% 262)", "l22": "oklch(22% 2.75% 262)", "l23": "oklch(23% 2.75% 262)", "l24": "oklch(24% 2.75% 262)", "l25": "oklch(25% 2.75% 262)", "l26": "oklch(26% 2.75% 262)", "l27": "oklch(27% 2.75% 262)", "l28": "oklch(28% 2.75% 262)", "l29": "oklch(29% 2.75% 262)", "l30": "oklch(30% 2.75% 262)", "l31": "oklch(31% 2.75% 262)", "l32": "oklch(32% 2.75% 262)", "l33": "oklch(33% 2.75% 262)", "l34": "oklch(34% 2.75% 262)", "l35": "oklch(35% 2.75% 262)", "l36": "oklch(36% 2.75% 262)", "l37": "oklch(37% 2.75% 262)", "l38": "oklch(38% 2.75% 262)", "l39": "oklch(39% 2.75% 262)", "l40": "oklch(40% 2.75% 262)", "l41": "oklch(41% 2.75% 262)", "l42": "oklch(42% 2.75% 262)", "l43": "oklch(43% 2.75% 262)", "l44": "oklch(44% 2.75% 262)", "l45": "oklch(45% 2.75% 262)", "l46": "oklch(46% 2.75% 262)", "l47": "oklch(47% 2.75% 262)", "l48": "oklch(48% 2.75% 262)", "l49": "oklch(49% 2.75% 262)", "l50": "oklch(50% 2.75% 262)", "l51": "oklch(51% 2.75% 262)", "l52": "oklch(52% 2.75% 262)", "l53": "oklch(53% 2.75% 262)", "l54": "oklch(54% 2.75% 262)", "l55": "oklch(55% 2.75% 262)", "l56": "oklch(56% 2.75% 262)", "l57": "oklch(57% 2.75% 262)", "l58": "oklch(58% 2.75% 262)", "l59": "oklch(59% 2.75% 262)", "l60": "oklch(60% 2.75% 262)", "l61": "oklch(61% 2.75% 262)", "l62": "oklch(62% 2.75% 262)", "l63": "oklch(63% 2.75% 262)", "l64": "oklch(64% 2.75% 262)", "l65": "oklch(65% 2.75% 262)", "l66": "oklch(66% 2.75% 262)", "l67": "oklch(67% 2.75% 262)", "l68": "oklch(68% 2.75% 262)", "l69": "oklch(69% 2.75% 262)", "l70": "oklch(70% 2.75% 262)", "l71": "oklch(71% 2.75% 262)", "l72": "oklch(72% 2.75% 262)", "l73": "oklch(73% 2.75% 262)", "l74": "oklch(74% 2.75% 262)", "l75": "oklch(75% 2.75% 262)", "l76": "oklch(76% 2.75% 262)", "l77": "oklch(77% 2.75% 262)", "l78": "oklch(78% 2.75% 262)", "l79": "oklch(79% 2.75% 262)", "l80": "oklch(80% 2.75% 262)", "l81": "oklch(81% 2.75% 262)", "l82": "oklch(82% 2.75% 262)", "l83": "oklch(83% 2.75% 262)", "l84": "oklch(84% 2.75% 262)", "l85": "oklch(85% 2.75% 262)", "l86": "oklch(86% 2.75% 262)", "l87": "oklch(87% 2.75% 262)", "l88": "oklch(88% 2.75% 262)", "l89": "oklch(89% 2.75% 262)", "l90": "oklch(90% 2.75% 262)", "l91": "oklch(91% 2.75% 262)", "l92": "oklch(92% 2.75% 262)", "l93": "oklch(93% 2.75% 262)", "l94": "oklch(94% 2.75% 262)", "l95": "oklch(95% 2.75% 262)"}, "red": {"l15": "oklch(15% 7.875% 29)", "l16": "oklch(16% 8.99% 29)", "l17": "oklch(17% 10.104% 29)", "l18": "oklch(18% 11.216% 29)", "l19": "oklch(19% 12.327% 29)", "l20": "oklch(20% 13.437% 29)", "l21": "oklch(21% 14.545% 29)", "l22": "oklch(22% 15.651% 29)", "l23": "oklch(23% 16.755% 29)", "l24": "oklch(24% 17.857% 29)", "l25": "oklch(25% 18.956% 29)", "l26": "oklch(26% 20.053% 29)", "l27": "oklch(27% 21.147% 29)", "l28": "oklch(28% 22.238% 29)", "l29": "oklch(29% 23.326% 29)", "l30": "oklch(30% 24.41% 29)", "l31": "oklch(31% 25.489% 29)", "l32": "oklch(32% 26.564% 29)", "l33": "oklch(33% 27.633% 29)", "l34": "oklch(34% 28.696% 29)", "l35": "oklch(35% 29.753% 29)", "l36": "oklch(36% 30.801% 29)", "l37": "oklch(37% 31.842% 29)", "l38": "oklch(38% 32.871% 29)", "l39": "oklch(39% 33.89% 29)", "l40": "oklch(40% 34.895% 29)", "l41": "oklch(41% 35.884% 29)", "l42": "oklch(42% 36.855% 29)", "l43": "oklch(43% 37.805% 29)", "l44": "oklch(44% 38.729% 29)", "l45": "oklch(45% 39.622% 29)", "l46": "oklch(46% 40.48% 29)", "l47": "oklch(47% 41.294% 29)", "l48": "oklch(48% 42.057% 29)", "l49": "oklch(49% 42.756% 29)", "l50": "oklch(50% 43.381% 29)", "l51": "oklch(51% 43.918% 29)", "l52": "oklch(52% 44.351% 29)", "l53": "oklch(53% 44.666% 29)", "l54": "oklch(54% 44.852% 29)", "l55": "oklch(55% 44.898% 29)", "l56": "oklch(56% 44.802% 29)", "l57": "oklch(57% 44.568% 29)", "l58": "oklch(58% 44.203% 29)", "l59": "oklch(59% 43.72% 29)", "l60": "oklch(60% 43.134% 29)", "l61": "oklch(61% 42.46% 29)", "l62": "oklch(62% 41.711% 29)", "l63": "oklch(63% 40.899% 29)", "l64": "oklch(64% 40.036% 29)", "l65": "oklch(65% 39.129% 29)", "l66": "oklch(66% 38.185% 29)", "l67": "oklch(67% 37.212% 29)", "l68": "oklch(68% 36.213% 29)", "l69": "oklch(69% 35.193% 29)", "l70": "oklch(70% 34.154% 29)", "l71": "oklch(71% 33.1% 29)", "l72": "oklch(72% 32.032% 29)", "l73": "oklch(73% 30.953% 29)", "l74": "oklch(74% 29.863% 29)", "l75": "oklch(75% 28.765% 29)", "l76": "oklch(76% 27.659% 29)", "l77": "oklch(77% 26.547% 29)", "l78": "oklch(78% 25.428% 29)", "l79": "oklch(79% 24.304% 29)", "l80": "oklch(80% 23.175% 29)", "l81": "oklch(81% 22.042% 29)", "l82": "oklch(82% 20.905% 29)", "l83": "oklch(83% 19.765% 29)", "l84": "oklch(84% 18.621% 29)", "l85": "oklch(85% 17.475% 29)", "l86": "oklch(86% 16.326% 29)", "l87": "oklch(87% 15.175% 29)", "l88": "oklch(88% 14.021% 29)", "l89": "oklch(89% 12.866% 29)", "l90": "oklch(90% 11.709% 29)", "l91": "oklch(91% 10.55% 29)", "l92": "oklch(92% 9.3894% 29)", "l93": "oklch(93% 8.2276% 29)", "l94": "oklch(94% 7.0644% 29)", "l95": "oklch(95% 5.9% 29)"}, "orange": {"l15": "oklch(15% 7.875% 62.5)", "l16": "oklch(16% 8.4903% 62.5)", "l17": "oklch(17% 9.1049% 62.5)", "l18": "oklch(18% 9.7187% 62.5)", "l19": "oklch(19% 10.332% 62.5)", "l20": "oklch(20% 10.944% 62.5)", "l21": "oklch(21% 11.555% 62.5)", "l22": "oklch(22% 12.165% 62.5)", "l23": "oklch(23% 12.775% 62.5)", "l24": "oklch(24% 13.383% 62.5)", "l25": "oklch(25% 13.989% 62.5)", "l26": "oklch(26% 14.594% 62.5)", "l27": "oklch(27% 15.198% 62.5)", "l28": "oklch(28% 15.8% 62.5)", "l29": "oklch(29% 16.399% 62.5)", "l30": "oklch(30% 16.997% 62.5)", "l31": "oklch(31% 17.592% 62.5)", "l32": "oklch(32% 18.185% 62.5)", "l33": "oklch(33% 18.775% 62.5)", "l34": "oklch(34% 19.361% 62.5)", "l35": "oklch(35% 19.943% 62.5)", "l36": "oklch(36% 20.521% 62.5)", "l37": "oklch(37% 21.095% 62.5)", "l38": "oklch(38% 21.662% 62.5)", "l39": "oklch(39% 22.223% 62.5)", "l40": "oklch(40% 22.777% 62.5)", "l41": "oklch(41% 23.321% 62.5)", "l42": "oklch(42% 23.856% 62.5)", "l43": "oklch(43% 24.378% 62.5)", "l44": "oklch(44% 24.886% 62.5)", "l45": "oklch(45% 25.377% 62.5)", "l46": "oklch(46% 25.848% 62.5)", "l47": "oklch(47% 26.294% 62.5)", "l48": "oklch(48% 26.712% 62.5)", "l49": "oklch(49% 27.094% 62.5)", "l50": "oklch(50% 27.434% 62.5)", "l51": "oklch(51% 27.724% 62.5)", "l52": "oklch(52% 27.957% 62.5)", "l53": "oklch(53% 28.123% 62.5)", "l54": "oklch(54% 28.216% 62.5)", "l55": "oklch(55% 28.231% 62.5)", "l56": "oklch(56% 28.167% 62.5)", "l57": "oklch(57% 28.024% 62.5)", "l58": "oklch(58% 27.808% 62.5)", "l59": "oklch(59% 27.527% 62.5)", "l60": "oklch(60% 27.187% 62.5)", "l61": "oklch(61% 26.797% 62.5)", "l62": "oklch(62% 26.366% 62.5)", "l63": "oklch(63% 25.899% 62.5)", "l64": "oklch(64% 25.404% 62.5)", "l65": "oklch(65% 24.883% 62.5)", "l66": "oklch(66% 24.343% 62.5)", "l67": "oklch(67% 23.786% 62.5)", "l68": "oklch(68% 23.214% 62.5)", "l69": "oklch(69% 22.63% 62.5)", "l70": "oklch(70% 22.036% 62.5)", "l71": "oklch(71% 21.433% 62.5)", "l72": "oklch(72% 20.823% 62.5)", "l73": "oklch(73% 20.206% 62.5)", "l74": "oklch(74% 19.583% 62.5)", "l75": "oklch(75% 18.956% 62.5)", "l76": "oklch(76% 18.324% 62.5)", "l77": "oklch(77% 17.688% 62.5)", "l78": "oklch(78% 17.049% 62.5)", "l79": "oklch(79% 16.407% 62.5)", "l80": "oklch(80% 15.763% 62.5)", "l81": "oklch(81% 15.116% 62.5)", "l82": "oklch(82% 14.466% 62.5)", "l83": "oklch(83% 13.815% 62.5)", "l84": "oklch(84% 13.162% 62.5)", "l85": "oklch(85% 12.508% 62.5)", "l86": "oklch(86% 11.852% 62.5)", "l87": "oklch(87% 11.195% 62.5)", "l88": "oklch(88% 10.536% 62.5)", "l89": "oklch(89% 9.8765% 62.5)", "l90": "oklch(90% 9.2158% 62.5)", "l91": "oklch(91% 8.5543% 62.5)", "l92": "oklch(92% 7.8918% 62.5)", "l93": "oklch(93% 7.2286% 62.5)", "l94": "oklch(94% 6.5647% 62.5)", "l95": "oklch(95% 5.9% 62.5)"}, "yellow": {"l15": "oklch(15% 7.875% 104)", "l16": "oklch(16% 8.2404% 104)", "l17": "oklch(17% 8.6054% 104)", "l18": "oklch(18% 8.97% 104)", "l19": "oklch(19% 9.334% 104)", "l20": "oklch(20% 9.6975% 104)", "l21": "oklch(21% 10.061% 104)", "l22": "oklch(22% 10.423% 104)", "l23": "oklch(23% 10.785% 104)", "l24": "oklch(24% 11.145% 104)", "l25": "oklch(25% 11.506% 104)", "l26": "oklch(26% 11.865% 104)", "l27": "oklch(27% 12.223% 104)", "l28": "oklch(28% 12.58% 104)", "l29": "oklch(29% 12.936% 104)", "l30": "oklch(30% 13.291% 104)", "l31": "oklch(31% 13.644% 104)", "l32": "oklch(32% 13.996% 104)", "l33": "oklch(33% 14.346% 104)", "l34": "oklch(34% 14.693% 104)", "l35": "oklch(35% 15.039% 104)", "l36": "oklch(36% 15.381% 104)", "l37": "oklch(37% 15.721% 104)", "l38": "oklch(38% 16.057% 104)", "l39": "oklch(39% 16.39% 104)", "l40": "oklch(40% 16.717% 104)", "l41": "oklch(41% 17.04% 104)", "l42": "oklch(42% 17.356% 104)", "l43": "oklch(43% 17.665% 104)", "l44": "oklch(44% 17.965% 104)", "l45": "oklch(45% 18.255% 104)", "l46": "oklch(46% 18.532% 104)", "l47": "oklch(47% 18.794% 104)", "l48": "oklch(48% 19.039% 104)", "l49": "oklch(49% 19.262% 104)", "l50": "oklch(50% 19.46% 104)", "l51": "oklch(51% 19.627% 104)", "l52": "oklch(52% 19.759% 104)", "l53": "oklch(53% 19.851% 104)", "l54": "oklch(54% 19.898% 104)", "l55": "oklch(55% 19.898% 104)", "l56": "oklch(56% 19.849% 104)", "l57": "oklch(57% 19.752% 104)", "l58": "oklch(58% 19.611% 104)", "l59": "oklch(59% 19.43% 104)", "l60": "oklch(60% 19.213% 104)", "l61": "oklch(61% 18.966% 104)", "l62": "oklch(62% 18.693% 104)", "l63": "oklch(63% 18.399% 104)", "l64": "oklch(64% 18.088% 104)", "l65": "oklch(65% 17.761% 104)", "l66": "oklch(66% 17.422% 104)", "l67": "oklch(67% 17.072% 104)", "l68": "oklch(68% 16.714% 104)", "l69": "oklch(69% 16.349% 104)", "l70": "oklch(70% 15.977% 104)", "l71": "oklch(71% 15.6% 104)", "l72": "oklch(72% 15.218% 104)", "l73": "oklch(73% 14.832% 104)", "l74": "oklch(74% 14.443% 104)", "l75": "oklch(75% 14.051% 104)", "l76": "oklch(76% 13.656% 104)", "l77": "oklch(77% 13.259% 104)", "l78": "oklch(78% 12.86% 104)", "l79": "oklch(79% 12.459% 104)", "l80": "oklch(80% 12.057% 104)", "l81": "oklch(81% 11.653% 104)", "l82": "oklch(82% 11.247% 104)", "l83": "oklch(83% 10.841% 104)", "l84": "oklch(84% 10.433% 104)", "l85": "oklch(85% 10.024% 104)", "l86": "oklch(86% 9.6148% 104)", "l87": "oklch(87% 9.2045% 104)", "l88": "oklch(88% 8.7935% 104)", "l89": "oklch(89% 8.3818% 104)", "l90": "oklch(90% 7.9694% 104)", "l91": "oklch(91% 7.5565% 104)", "l92": "oklch(92% 7.1431% 104)", "l93": "oklch(93% 6.7292% 104)", "l94": "oklch(94% 6.3148% 104)", "l95": "oklch(95% 5.9% 104)"}, "green": {"l15": "oklch(15% 7.875% 148)", "l16": "oklch(16% 8.4903% 148)", "l17": "oklch(17% 9.1049% 148)", "l18": "oklch(18% 9.7187% 148)", "l19": "oklch(19% 10.332% 148)", "l20": "oklch(20% 10.944% 148)", "l21": "oklch(21% 11.555% 148)", "l22": "oklch(22% 12.165% 148)", "l23": "oklch(23% 12.775% 148)", "l24": "oklch(24% 13.383% 148)", "l25": "oklch(25% 13.989% 148)", "l26": "oklch(26% 14.594% 148)", "l27": "oklch(27% 15.198% 148)", "l28": "oklch(28% 15.8% 148)", "l29": "oklch(29% 16.399% 148)", "l30": "oklch(30% 16.997% 148)", "l31": "oklch(31% 17.592% 148)", "l32": "oklch(32% 18.185% 148)", "l33": "oklch(33% 18.775% 148)", "l34": "oklch(34% 19.361% 148)", "l35": "oklch(35% 19.943% 148)", "l36": "oklch(36% 20.521% 148)", "l37": "oklch(37% 21.095% 148)", "l38": "oklch(38% 21.662% 148)", "l39": "oklch(39% 22.223% 148)", "l40": "oklch(40% 22.777% 148)", "l41": "oklch(41% 23.321% 148)", "l42": "oklch(42% 23.856% 148)", "l43": "oklch(43% 24.378% 148)", "l44": "oklch(44% 24.886% 148)", "l45": "oklch(45% 25.377% 148)", "l46": "oklch(46% 25.848% 148)", "l47": "oklch(47% 26.294% 148)", "l48": "oklch(48% 26.712% 148)", "l49": "oklch(49% 27.094% 148)", "l50": "oklch(50% 27.434% 148)", "l51": "oklch(51% 27.724% 148)", "l52": "oklch(52% 27.957% 148)", "l53": "oklch(53% 28.123% 148)", "l54": "oklch(54% 28.216% 148)", "l55": "oklch(55% 28.231% 148)", "l56": "oklch(56% 28.167% 148)", "l57": "oklch(57% 28.024% 148)", "l58": "oklch(58% 27.808% 148)", "l59": "oklch(59% 27.527% 148)", "l60": "oklch(60% 27.187% 148)", "l61": "oklch(61% 26.797% 148)", "l62": "oklch(62% 26.366% 148)", "l63": "oklch(63% 25.899% 148)", "l64": "oklch(64% 25.404% 148)", "l65": "oklch(65% 24.883% 148)", "l66": "oklch(66% 24.343% 148)", "l67": "oklch(67% 23.786% 148)", "l68": "oklch(68% 23.214% 148)", "l69": "oklch(69% 22.63% 148)", "l70": "oklch(70% 22.036% 148)", "l71": "oklch(71% 21.433% 148)", "l72": "oklch(72% 20.823% 148)", "l73": "oklch(73% 20.206% 148)", "l74": "oklch(74% 19.583% 148)", "l75": "oklch(75% 18.956% 148)", "l76": "oklch(76% 18.324% 148)", "l77": "oklch(77% 17.688% 148)", "l78": "oklch(78% 17.049% 148)", "l79": "oklch(79% 16.407% 148)", "l80": "oklch(80% 15.763% 148)", "l81": "oklch(81% 15.116% 148)", "l82": "oklch(82% 14.466% 148)", "l83": "oklch(83% 13.815% 148)", "l84": "oklch(84% 13.162% 148)", "l85": "oklch(85% 12.508% 148)", "l86": "oklch(86% 11.852% 148)", "l87": "oklch(87% 11.195% 148)", "l88": "oklch(88% 10.536% 148)", "l89": "oklch(89% 9.8765% 148)", "l90": "oklch(90% 9.2158% 148)", "l91": "oklch(91% 8.5543% 148)", "l92": "oklch(92% 7.8918% 148)", "l93": "oklch(93% 7.2286% 148)", "l94": "oklch(94% 6.5647% 148)", "l95": "oklch(95% 5.9% 148)"}, "blue": {"l15": "oklch(15% 7.875% 262)", "l16": "oklch(16% 8.6152% 262)", "l17": "oklch(17% 9.3546% 262)", "l18": "oklch(18% 10.093% 262)", "l19": "oklch(19% 10.831% 262)", "l20": "oklch(20% 11.567% 262)", "l21": "oklch(21% 12.303% 262)", "l22": "oklch(22% 13.037% 262)", "l23": "oklch(23% 13.77% 262)", "l24": "oklch(24% 14.501% 262)", "l25": "oklch(25% 15.231% 262)", "l26": "oklch(26% 15.959% 262)", "l27": "oklch(27% 16.685% 262)", "l28": "oklch(28% 17.409% 262)", "l29": "oklch(29% 18.131% 262)", "l30": "oklch(30% 18.85% 262)", "l31": "oklch(31% 19.567% 262)", "l32": "oklch(32% 20.28% 262)", "l33": "oklch(33% 20.989% 262)", "l34": "oklch(34% 21.695% 262)", "l35": "oklch(35% 22.396% 262)", "l36": "oklch(36% 23.091% 262)", "l37": "oklch(37% 23.781% 262)", "l38": "oklch(38% 24.464% 262)", "l39": "oklch(39% 25.14% 262)", "l40": "oklch(40% 25.806% 262)", "l41": "oklch(41% 26.462% 262)", "l42": "oklch(42% 27.105% 262)", "l43": "oklch(43% 27.735% 262)", "l44": "oklch(44% 28.347% 262)", "l45": "oklch(45% 28.938% 262)", "l46": "oklch(46% 29.506% 262)", "l47": "oklch(47% 30.044% 262)", "l48": "oklch(48% 30.548% 262)", "l49": "oklch(49% 31.009% 262)", "l50": "oklch(50% 31.421% 262)", "l51": "oklch(51% 31.772% 262)", "l52": "oklch(52% 32.055% 262)", "l53": "oklch(53% 32.259% 262)", "l54": "oklch(54% 32.375% 262)", "l55": "oklch(55% 32.398% 262)", "l56": "oklch(56% 32.326% 262)", "l57": "oklch(57% 32.16% 262)", "l58": "oklch(58% 31.907% 262)", "l59": "oklch(59% 31.575% 262)", "l60": "oklch(60% 31.174% 262)", "l61": "oklch(61% 30.713% 262)", "l62": "oklch(62% 30.202% 262)", "l63": "oklch(63% 29.649% 262)", "l64": "oklch(64% 29.062% 262)", "l65": "oklch(65% 28.445% 262)", "l66": "oklch(66% 27.804% 262)", "l67": "oklch(67% 27.142% 262)", "l68": "oklch(68% 26.464% 262)", "l69": "oklch(69% 25.771% 262)", "l70": "oklch(70% 25.065% 262)", "l71": "oklch(71% 24.35% 262)", "l72": "oklch(72% 23.625% 262)", "l73": "oklch(73% 22.893% 262)", "l74": "oklch(74% 22.153% 262)", "l75": "oklch(75% 21.408% 262)", "l76": "oklch(76% 20.658% 262)", "l77": "oklch(77% 19.903% 262)", "l78": "oklch(78% 19.144% 262)", "l79": "oklch(79% 18.382% 262)", "l80": "oklch(80% 17.616% 262)", "l81": "oklch(81% 16.847% 262)", "l82": "oklch(82% 16.076% 262)", "l83": "oklch(83% 15.303% 262)", "l84": "oklch(84% 14.527% 262)", "l85": "oklch(85% 13.75% 262)", "l86": "oklch(86% 12.97% 262)", "l87": "oklch(87% 12.19% 262)", "l88": "oklch(88% 11.407% 262)", "l89": "oklch(89% 10.624% 262)", "l90": "oklch(90% 9.839% 262)", "l91": "oklch(91% 9.0531% 262)", "l92": "oklch(92% 8.2662% 262)", "l93": "oklch(93% 7.4784% 262)", "l94": "oklch(94% 6.6896% 262)", "l95": "oklch(95% 5.9% 262)"}} \ No newline at end of file diff --git a/notebooks/palettes/monobiome-vMCL.toml b/notebooks/palettes/monobiome-vMCL.toml new file mode 100644 index 0000000..bbb0024 --- /dev/null +++ b/notebooks/palettes/monobiome-vMCL.toml @@ -0,0 +1,912 @@ +[alpine] +l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" +l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" +l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" +l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" +l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" +l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" +l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" +l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" +l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" +l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" +l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" +l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" +l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" +l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" +l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" +l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" +l95 = "#eeeeee" + +[badlands] +l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" +l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" +l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" +l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" +l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" +l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" +l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" +l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" +l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" +l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" +l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" +l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" +l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" +l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" +l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" +l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" +l95 = "#f6ecea" + +[chaparral] +l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" +l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" +l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" +l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" +l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" +l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" +l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" +l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" +l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" +l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" +l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" +l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" +l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" +l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" +l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" +l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" +l95 = "#f4ede7" + +[savanna] +l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" +l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" +l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" +l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" +l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" +l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" +l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" +l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" +l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" +l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" +l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" +l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" +l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" +l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" +l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" +l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" +l95 = "#efefe7" + +[grassland] +l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" +l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" +l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" +l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" +l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" +l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" +l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" +l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" +l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" +l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" +l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" +l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" +l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" +l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" +l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" +l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" +l95 = "#eaf1ea" + +[tundra] +l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" +l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" +l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" +l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" +l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" +l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" +l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" +l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" +l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" +l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" +l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" +l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" +l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" +l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" +l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" +l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" +l95 = "#eaeff6" + +[red] +l15 = "#160604" +l16 = "#1a0705" +l17 = "#1e0805" +l18 = "#220806" +l19 = "#260907" +l20 = "#2a0a07" +l21 = "#2e0b08" +l22 = "#320c08" +l23 = "#360d09" +l24 = "#3a0e09" +l25 = "#3f0f0a" +l26 = "#43100b" +l27 = "#47100b" +l28 = "#4c110c" +l29 = "#50120d" +l30 = "#55130d" +l31 = "#59140e" +l32 = "#5e140f" +l33 = "#62150f" +l34 = "#671610" +l35 = "#6b1711" +l36 = "#701811" +l37 = "#751912" +l38 = "#791913" +l39 = "#7e1a13" +l40 = "#831b14" +l41 = "#871c15" +l42 = "#8c1d16" +l43 = "#911e17" +l44 = "#951f18" +l45 = "#9a2119" +l46 = "#9f221a" +l47 = "#a3241b" +l48 = "#a8251c" +l49 = "#ac271e" +l50 = "#b12920" +l51 = "#b52c22" +l52 = "#b92e24" +l53 = "#bd3126" +l54 = "#c13429" +l55 = "#c5382c" +l56 = "#c83b2f" +l57 = "#cb4033" +l58 = "#ce4437" +l59 = "#d1483b" +l60 = "#d34d3f" +l61 = "#d65143" +l62 = "#d85647" +l63 = "#da5a4c" +l64 = "#dc5f50" +l65 = "#de6455" +l66 = "#e06859" +l67 = "#e26d5e" +l68 = "#e47163" +l69 = "#e57667" +l70 = "#e77b6c" +l71 = "#e87f71" +l72 = "#ea8475" +l73 = "#eb887a" +l74 = "#ed8d7f" +l75 = "#ee9183" +l76 = "#ef9688" +l77 = "#f09a8d" +l78 = "#f19e92" +l79 = "#f3a397" +l80 = "#f4a79b" +l81 = "#f5aca0" +l82 = "#f6b0a5" +l83 = "#f7b4aa" +l84 = "#f7b9af" +l85 = "#f8bdb4" +l86 = "#f9c2b9" +l87 = "#fac6be" +l88 = "#fbcac3" +l89 = "#fbcfc7" +l90 = "#fcd3cc" +l91 = "#fcd8d1" +l92 = "#fddcd6" +l93 = "#fde0db" +l94 = "#fee5e0" +l95 = "#fee9e5" + +[orange] +l15 = "#140801" +l16 = "#170901" +l17 = "#1a0b01" +l18 = "#1d0d01" +l19 = "#210f01" +l20 = "#241101" +l21 = "#271301" +l22 = "#2a1501" +l23 = "#2d1701" +l24 = "#311801" +l25 = "#341a01" +l26 = "#371c01" +l27 = "#3b1e01" +l28 = "#3e2101" +l29 = "#422301" +l30 = "#452501" +l31 = "#492701" +l32 = "#4c2901" +l33 = "#502b01" +l34 = "#532d01" +l35 = "#572f01" +l36 = "#5b3201" +l37 = "#5e3401" +l38 = "#623601" +l39 = "#663801" +l40 = "#693b01" +l41 = "#6d3d01" +l42 = "#713f01" +l43 = "#754102" +l44 = "#784402" +l45 = "#7c4603" +l46 = "#804904" +l47 = "#834b06" +l48 = "#874e07" +l49 = "#8b5009" +l50 = "#8e530c" +l51 = "#92550f" +l52 = "#955812" +l53 = "#995b16" +l54 = "#9c5e19" +l55 = "#9f611d" +l56 = "#a26421" +l57 = "#a56726" +l58 = "#a86a2a" +l59 = "#ab6d2f" +l60 = "#ae7034" +l61 = "#b07438" +l62 = "#b3773d" +l63 = "#b57a42" +l64 = "#b87e47" +l65 = "#ba814c" +l66 = "#bd8450" +l67 = "#bf8855" +l68 = "#c18b5a" +l69 = "#c48f5f" +l70 = "#c69264" +l71 = "#c89669" +l72 = "#ca996d" +l73 = "#cd9d72" +l74 = "#cfa077" +l75 = "#d1a47c" +l76 = "#d3a781" +l77 = "#d5ab86" +l78 = "#d8ae8b" +l79 = "#dab28f" +l80 = "#dcb594" +l81 = "#deb999" +l82 = "#e0bd9e" +l83 = "#e2c0a3" +l84 = "#e4c4a8" +l85 = "#e6c7ad" +l86 = "#e8cbb2" +l87 = "#eaceb7" +l88 = "#ecd2bc" +l89 = "#eed6c1" +l90 = "#f1d9c6" +l91 = "#f3ddcb" +l92 = "#f5e1d0" +l93 = "#f7e4d5" +l94 = "#f9e8da" +l95 = "#fbebdf" + +[yellow] +l15 = "#0d0c00" +l16 = "#100e00" +l17 = "#121000" +l18 = "#141201" +l19 = "#171401" +l20 = "#191702" +l21 = "#1b1902" +l22 = "#1e1b03" +l23 = "#201e03" +l24 = "#232004" +l25 = "#252305" +l26 = "#282506" +l27 = "#2a2707" +l28 = "#2d2a08" +l29 = "#302c09" +l30 = "#322f0b" +l31 = "#35310c" +l32 = "#38340e" +l33 = "#3a370f" +l34 = "#3d3911" +l35 = "#403c12" +l36 = "#433f14" +l37 = "#454115" +l38 = "#484417" +l39 = "#4b4718" +l40 = "#4e491a" +l41 = "#514c1c" +l42 = "#534f1d" +l43 = "#56521f" +l44 = "#595421" +l45 = "#5c5722" +l46 = "#5f5a24" +l47 = "#625d26" +l48 = "#656028" +l49 = "#68622a" +l50 = "#6b652d" +l51 = "#6e682f" +l52 = "#706b31" +l53 = "#736e34" +l54 = "#767137" +l55 = "#79743a" +l56 = "#7c773d" +l57 = "#7f7a40" +l58 = "#827d43" +l59 = "#858047" +l60 = "#88834b" +l61 = "#8b864e" +l62 = "#8d8952" +l63 = "#908c56" +l64 = "#938f5a" +l65 = "#96925e" +l66 = "#999562" +l67 = "#9c9866" +l68 = "#9f9b6a" +l69 = "#a29e6e" +l70 = "#a5a172" +l71 = "#a8a476" +l72 = "#aba77b" +l73 = "#adaa7f" +l74 = "#b0ad83" +l75 = "#b3b087" +l76 = "#b6b38b" +l77 = "#b9b690" +l78 = "#bcba94" +l79 = "#bfbd98" +l80 = "#c2c09c" +l81 = "#c5c3a1" +l82 = "#c8c6a5" +l83 = "#cbc9a9" +l84 = "#cfccad" +l85 = "#d2d0b2" +l86 = "#d5d3b6" +l87 = "#d8d6ba" +l88 = "#dbd9bf" +l89 = "#dedcc3" +l90 = "#e1dfc8" +l91 = "#e4e3cc" +l92 = "#e7e6d0" +l93 = "#eae9d5" +l94 = "#eeecd9" +l95 = "#f1f0de" + +[green] +l15 = "#030f04" +l16 = "#031105" +l17 = "#041406" +l18 = "#051607" +l19 = "#051909" +l20 = "#061b0a" +l21 = "#071e0b" +l22 = "#08210d" +l23 = "#09230e" +l24 = "#0a2610" +l25 = "#0b2911" +l26 = "#0c2b13" +l27 = "#0d2e14" +l28 = "#0f3116" +l29 = "#103417" +l30 = "#113719" +l31 = "#123a1b" +l32 = "#133d1c" +l33 = "#15401e" +l34 = "#16421f" +l35 = "#174521" +l36 = "#184823" +l37 = "#1a4b24" +l38 = "#1b4f26" +l39 = "#1d5228" +l40 = "#1e552a" +l41 = "#1f582c" +l42 = "#215b2d" +l43 = "#225e2f" +l44 = "#246131" +l45 = "#266433" +l46 = "#276735" +l47 = "#296a37" +l48 = "#2b6e39" +l49 = "#2d713b" +l50 = "#2f743d" +l51 = "#327740" +l52 = "#347a42" +l53 = "#377d45" +l54 = "#3a8047" +l55 = "#3d834a" +l56 = "#40864d" +l57 = "#438950" +l58 = "#478c53" +l59 = "#4b8f57" +l60 = "#4f925a" +l61 = "#53955e" +l62 = "#579861" +l63 = "#5b9a65" +l64 = "#5f9d68" +l65 = "#63a06c" +l66 = "#67a370" +l67 = "#6ba674" +l68 = "#70a878" +l69 = "#74ab7b" +l70 = "#78ae7f" +l71 = "#7cb183" +l72 = "#81b387" +l73 = "#85b68b" +l74 = "#89b98f" +l75 = "#8dbc93" +l76 = "#92be97" +l77 = "#96c19b" +l78 = "#9ac49f" +l79 = "#9fc7a3" +l80 = "#a3c9a7" +l81 = "#a7ccab" +l82 = "#accfaf" +l83 = "#b0d2b3" +l84 = "#b4d5b8" +l85 = "#b9d7bc" +l86 = "#bddac0" +l87 = "#c1ddc4" +l88 = "#c6e0c8" +l89 = "#cae2cc" +l90 = "#cee5d1" +l91 = "#d3e8d5" +l92 = "#d7ebd9" +l93 = "#dceedd" +l94 = "#e0f0e2" +l95 = "#e4f3e6" + +[blue] +l15 = "#050b18" +l16 = "#060d1c" +l17 = "#070f20" +l18 = "#081123" +l19 = "#091327" +l20 = "#0a152b" +l21 = "#0b182f" +l22 = "#0d1a33" +l23 = "#0e1c36" +l24 = "#0f1e3a" +l25 = "#11213f" +l26 = "#122343" +l27 = "#142547" +l28 = "#15284b" +l29 = "#162a4f" +l30 = "#182c53" +l31 = "#192f57" +l32 = "#1b315c" +l33 = "#1c3460" +l34 = "#1e3664" +l35 = "#1f3969" +l36 = "#213b6d" +l37 = "#233e71" +l38 = "#244076" +l39 = "#26437a" +l40 = "#27457f" +l41 = "#294883" +l42 = "#2b4b88" +l43 = "#2c4d8c" +l44 = "#2e5090" +l45 = "#305395" +l46 = "#325599" +l47 = "#34589d" +l48 = "#365ba2" +l49 = "#385ea6" +l50 = "#3a60aa" +l51 = "#3c63ae" +l52 = "#3e66b2" +l53 = "#4169b6" +l54 = "#436cb9" +l55 = "#466fbd" +l56 = "#4972c0" +l57 = "#4c75c3" +l58 = "#4f78c5" +l59 = "#537bc8" +l60 = "#567fca" +l61 = "#5a82cd" +l62 = "#5d85cf" +l63 = "#6188d1" +l64 = "#658bd3" +l65 = "#688ed5" +l66 = "#6c92d6" +l67 = "#7095d8" +l68 = "#7498da" +l69 = "#789bdb" +l70 = "#7c9edd" +l71 = "#80a2df" +l72 = "#84a5e0" +l73 = "#88a8e2" +l74 = "#8cabe3" +l75 = "#90aee5" +l76 = "#95b2e6" +l77 = "#99b5e8" +l78 = "#9db8e9" +l79 = "#a1bbeb" +l80 = "#a5bfec" +l81 = "#a9c2ed" +l82 = "#aec5ef" +l83 = "#b2c8f0" +l84 = "#b6cbf1" +l85 = "#bacff3" +l86 = "#bfd2f4" +l87 = "#c3d5f5" +l88 = "#c7d8f6" +l89 = "#ccdcf8" +l90 = "#d0dff9" +l91 = "#d4e2fa" +l92 = "#d9e5fb" +l93 = "#dde8fd" +l94 = "#e2ecfe" +l95 = "#e6efff" diff --git a/notebooks/palettes/monobiome-vQBR-oklch.json b/notebooks/palettes/monobiome-vQBR-oklch.json new file mode 100644 index 0000000..8ddc51a --- /dev/null +++ b/notebooks/palettes/monobiome-vQBR-oklch.json @@ -0,0 +1 @@ +{"alpine": {"10": "oklch(0.1 0 0)", "11": "oklch(0.11 0 0)", "12": "oklch(0.12 0 0)", "13": "oklch(0.13 0 0)", "14": "oklch(0.14 0 0)", "15": "oklch(0.15 0 0)", "16": "oklch(0.16 0 0)", "17": "oklch(0.17 0 0)", "18": "oklch(0.18 0 0)", "19": "oklch(0.19 0 0)", "20": "oklch(0.2 0 0)", "21": "oklch(0.21 0 0)", "22": "oklch(0.22 0 0)", "23": "oklch(0.23 0 0)", "24": "oklch(0.24 0 0)", "25": "oklch(0.25 0 0)", "26": "oklch(0.26 0 0)", "27": "oklch(0.27 0 0)", "28": "oklch(0.28 0 0)", "29": "oklch(0.29 0 0)", "30": "oklch(0.3 0 0)", "31": "oklch(0.31 0 0)", "32": "oklch(0.32 0 0)", "33": "oklch(0.33 0 0)", "34": "oklch(0.34 0 0)", "35": "oklch(0.35 0 0)", "36": "oklch(0.36 0 0)", "37": "oklch(0.37 0 0)", "38": "oklch(0.38 0 0)", "39": "oklch(0.39 0 0)", "40": "oklch(0.4 0 0)", "41": "oklch(0.41 0 0)", "42": "oklch(0.42 0 0)", "43": "oklch(0.43 0 0)", "44": "oklch(0.44 0 0)", "45": "oklch(0.45 0 0)", "46": "oklch(0.46 0 0)", "47": "oklch(0.47 0 0)", "48": "oklch(0.48 0 0)", "49": "oklch(0.49 0 0)", "50": "oklch(0.5 0 0)", "51": "oklch(0.51 0 0)", "52": "oklch(0.52 0 0)", "53": "oklch(0.53 0 0)", "54": "oklch(0.54 0 0)", "55": "oklch(0.55 0 0)", "56": "oklch(0.56 0 0)", "57": "oklch(0.57 0 0)", "58": "oklch(0.58 0 0)", "59": "oklch(0.59 0 0)", "60": "oklch(0.6 0 0)", "61": "oklch(0.61 0 0)", "62": "oklch(0.62 0 0)", "63": "oklch(0.63 0 0)", "64": "oklch(0.64 0 0)", "65": "oklch(0.65 0 0)", "66": "oklch(0.66 0 0)", "67": "oklch(0.67 0 0)", "68": "oklch(0.68 0 0)", "69": "oklch(0.69 0 0)", "70": "oklch(0.7 0 0)", "71": "oklch(0.71 0 0)", "72": "oklch(0.72 0 0)", "73": "oklch(0.73 0 0)", "74": "oklch(0.74 0 0)", "75": "oklch(0.75 0 0)", "76": "oklch(0.76 0 0)", "77": "oklch(0.77 0 0)", "78": "oklch(0.78 0 0)", "79": "oklch(0.79 0 0)", "80": "oklch(0.8 0 0)", "81": "oklch(0.81 0 0)", "82": "oklch(0.82 0 0)", "83": "oklch(0.83 0 0)", "84": "oklch(0.84 0 0)", "85": "oklch(0.85 0 0)", "86": "oklch(0.86 0 0)", "87": "oklch(0.87 0 0)", "88": "oklch(0.88 0 0)", "89": "oklch(0.89 0 0)", "90": "oklch(0.9 0 0)", "91": "oklch(0.91 0 0)", "92": "oklch(0.92 0 0)", "93": "oklch(0.93 0 0)", "94": "oklch(0.94 0 0)", "95": "oklch(0.95 0 0)", "96": "oklch(0.96 0 0)", "97": "oklch(0.97 0 0)", "98": "oklch(0.98 0 0)"}, "badlands": {"10": "oklch(0.1 0.011 29)", "11": "oklch(0.11 0.011 29)", "12": "oklch(0.12 0.011 29)", "13": "oklch(0.13 0.011 29)", "14": "oklch(0.14 0.011 29)", "15": "oklch(0.15 0.011 29)", "16": "oklch(0.16 0.011 29)", "17": "oklch(0.17 0.011 29)", "18": "oklch(0.18 0.011 29)", "19": "oklch(0.19 0.011 29)", "20": "oklch(0.2 0.011 29)", "21": "oklch(0.21 0.011 29)", "22": "oklch(0.22 0.011 29)", "23": "oklch(0.23 0.011 29)", "24": "oklch(0.24 0.011 29)", "25": "oklch(0.25 0.011 29)", "26": "oklch(0.26 0.011 29)", "27": "oklch(0.27 0.011 29)", "28": "oklch(0.28 0.011 29)", "29": "oklch(0.29 0.011 29)", "30": "oklch(0.3 0.011 29)", "31": "oklch(0.31 0.011 29)", "32": "oklch(0.32 0.011 29)", "33": "oklch(0.33 0.011 29)", "34": "oklch(0.34 0.011 29)", "35": "oklch(0.35 0.011 29)", "36": "oklch(0.36 0.011 29)", "37": "oklch(0.37 0.011 29)", "38": "oklch(0.38 0.011 29)", "39": "oklch(0.39 0.011 29)", "40": "oklch(0.4 0.011 29)", "41": "oklch(0.41 0.011 29)", "42": "oklch(0.42 0.011 29)", "43": "oklch(0.43 0.011 29)", "44": "oklch(0.44 0.011 29)", "45": "oklch(0.45 0.011 29)", "46": "oklch(0.46 0.011 29)", "47": "oklch(0.47 0.011 29)", "48": "oklch(0.48 0.011 29)", "49": "oklch(0.49 0.011 29)", "50": "oklch(0.5 0.011 29)", "51": "oklch(0.51 0.011 29)", "52": "oklch(0.52 0.011 29)", "53": "oklch(0.53 0.011 29)", "54": "oklch(0.54 0.011 29)", "55": "oklch(0.55 0.011 29)", "56": "oklch(0.56 0.011 29)", "57": "oklch(0.57 0.011 29)", "58": "oklch(0.58 0.011 29)", "59": "oklch(0.59 0.011 29)", "60": "oklch(0.6 0.011 29)", "61": "oklch(0.61 0.011 29)", "62": "oklch(0.62 0.011 29)", "63": "oklch(0.63 0.011 29)", "64": "oklch(0.64 0.011 29)", "65": "oklch(0.65 0.011 29)", "66": "oklch(0.66 0.011 29)", "67": "oklch(0.67 0.011 29)", "68": "oklch(0.68 0.011 29)", "69": "oklch(0.69 0.011 29)", "70": "oklch(0.7 0.011 29)", "71": "oklch(0.71 0.011 29)", "72": "oklch(0.72 0.011 29)", "73": "oklch(0.73 0.011 29)", "74": "oklch(0.74 0.011 29)", "75": "oklch(0.75 0.011 29)", "76": "oklch(0.76 0.011 29)", "77": "oklch(0.77 0.011 29)", "78": "oklch(0.78 0.011 29)", "79": "oklch(0.79 0.011 29)", "80": "oklch(0.8 0.011 29)", "81": "oklch(0.81 0.011 29)", "82": "oklch(0.82 0.011 29)", "83": "oklch(0.83 0.011 29)", "84": "oklch(0.84 0.011 29)", "85": "oklch(0.85 0.011 29)", "86": "oklch(0.86 0.011 29)", "87": "oklch(0.87 0.011 29)", "88": "oklch(0.88 0.011 29)", "89": "oklch(0.89 0.011 29)", "90": "oklch(0.9 0.011 29)", "91": "oklch(0.91 0.011 29)", "92": "oklch(0.92 0.011 29)", "93": "oklch(0.93 0.011 29)", "94": "oklch(0.94 0.011 29)", "95": "oklch(0.95 0.011 29)", "96": "oklch(0.96 0.011 29)", "97": "oklch(0.97 0.011 29)", "98": "oklch(0.98 0.00975 29)"}, "chaparral": {"10": "oklch(0.1 0.011 62.5)", "11": "oklch(0.11 0.011 62.5)", "12": "oklch(0.12 0.011 62.5)", "13": "oklch(0.13 0.011 62.5)", "14": "oklch(0.14 0.011 62.5)", "15": "oklch(0.15 0.011 62.5)", "16": "oklch(0.16 0.011 62.5)", "17": "oklch(0.17 0.011 62.5)", "18": "oklch(0.18 0.011 62.5)", "19": "oklch(0.19 0.011 62.5)", "20": "oklch(0.2 0.011 62.5)", "21": "oklch(0.21 0.011 62.5)", "22": "oklch(0.22 0.011 62.5)", "23": "oklch(0.23 0.011 62.5)", "24": "oklch(0.24 0.011 62.5)", "25": "oklch(0.25 0.011 62.5)", "26": "oklch(0.26 0.011 62.5)", "27": "oklch(0.27 0.011 62.5)", "28": "oklch(0.28 0.011 62.5)", "29": "oklch(0.29 0.011 62.5)", "30": "oklch(0.3 0.011 62.5)", "31": "oklch(0.31 0.011 62.5)", "32": "oklch(0.32 0.011 62.5)", "33": "oklch(0.33 0.011 62.5)", "34": "oklch(0.34 0.011 62.5)", "35": "oklch(0.35 0.011 62.5)", "36": "oklch(0.36 0.011 62.5)", "37": "oklch(0.37 0.011 62.5)", "38": "oklch(0.38 0.011 62.5)", "39": "oklch(0.39 0.011 62.5)", "40": "oklch(0.4 0.011 62.5)", "41": "oklch(0.41 0.011 62.5)", "42": "oklch(0.42 0.011 62.5)", "43": "oklch(0.43 0.011 62.5)", "44": "oklch(0.44 0.011 62.5)", "45": "oklch(0.45 0.011 62.5)", "46": "oklch(0.46 0.011 62.5)", "47": "oklch(0.47 0.011 62.5)", "48": "oklch(0.48 0.011 62.5)", "49": "oklch(0.49 0.011 62.5)", "50": "oklch(0.5 0.011 62.5)", "51": "oklch(0.51 0.011 62.5)", "52": "oklch(0.52 0.011 62.5)", "53": "oklch(0.53 0.011 62.5)", "54": "oklch(0.54 0.011 62.5)", "55": "oklch(0.55 0.011 62.5)", "56": "oklch(0.56 0.011 62.5)", "57": "oklch(0.57 0.011 62.5)", "58": "oklch(0.58 0.011 62.5)", "59": "oklch(0.59 0.011 62.5)", "60": "oklch(0.6 0.011 62.5)", "61": "oklch(0.61 0.011 62.5)", "62": "oklch(0.62 0.011 62.5)", "63": "oklch(0.63 0.011 62.5)", "64": "oklch(0.64 0.011 62.5)", "65": "oklch(0.65 0.011 62.5)", "66": "oklch(0.66 0.011 62.5)", "67": "oklch(0.67 0.011 62.5)", "68": "oklch(0.68 0.011 62.5)", "69": "oklch(0.69 0.011 62.5)", "70": "oklch(0.7 0.011 62.5)", "71": "oklch(0.71 0.011 62.5)", "72": "oklch(0.72 0.011 62.5)", "73": "oklch(0.73 0.011 62.5)", "74": "oklch(0.74 0.011 62.5)", "75": "oklch(0.75 0.011 62.5)", "76": "oklch(0.76 0.011 62.5)", "77": "oklch(0.77 0.011 62.5)", "78": "oklch(0.78 0.011 62.5)", "79": "oklch(0.79 0.011 62.5)", "80": "oklch(0.8 0.011 62.5)", "81": "oklch(0.81 0.011 62.5)", "82": "oklch(0.82 0.011 62.5)", "83": "oklch(0.83 0.011 62.5)", "84": "oklch(0.84 0.011 62.5)", "85": "oklch(0.85 0.011 62.5)", "86": "oklch(0.86 0.011 62.5)", "87": "oklch(0.87 0.011 62.5)", "88": "oklch(0.88 0.011 62.5)", "89": "oklch(0.89 0.011 62.5)", "90": "oklch(0.9 0.011 62.5)", "91": "oklch(0.91 0.011 62.5)", "92": "oklch(0.92 0.011 62.5)", "93": "oklch(0.93 0.011 62.5)", "94": "oklch(0.94 0.011 62.5)", "95": "oklch(0.95 0.011 62.5)", "96": "oklch(0.96 0.011 62.5)", "97": "oklch(0.97 0.011 62.5)", "98": "oklch(0.98 0.011 62.5)"}, "savanna": {"10": "oklch(0.1 0.011 104)", "11": "oklch(0.11 0.011 104)", "12": "oklch(0.12 0.011 104)", "13": "oklch(0.13 0.011 104)", "14": "oklch(0.14 0.011 104)", "15": "oklch(0.15 0.011 104)", "16": "oklch(0.16 0.011 104)", "17": "oklch(0.17 0.011 104)", "18": "oklch(0.18 0.011 104)", "19": "oklch(0.19 0.011 104)", "20": "oklch(0.2 0.011 104)", "21": "oklch(0.21 0.011 104)", "22": "oklch(0.22 0.011 104)", "23": "oklch(0.23 0.011 104)", "24": "oklch(0.24 0.011 104)", "25": "oklch(0.25 0.011 104)", "26": "oklch(0.26 0.011 104)", "27": "oklch(0.27 0.011 104)", "28": "oklch(0.28 0.011 104)", "29": "oklch(0.29 0.011 104)", "30": "oklch(0.3 0.011 104)", "31": "oklch(0.31 0.011 104)", "32": "oklch(0.32 0.011 104)", "33": "oklch(0.33 0.011 104)", "34": "oklch(0.34 0.011 104)", "35": "oklch(0.35 0.011 104)", "36": "oklch(0.36 0.011 104)", "37": "oklch(0.37 0.011 104)", "38": "oklch(0.38 0.011 104)", "39": "oklch(0.39 0.011 104)", "40": "oklch(0.4 0.011 104)", "41": "oklch(0.41 0.011 104)", "42": "oklch(0.42 0.011 104)", "43": "oklch(0.43 0.011 104)", "44": "oklch(0.44 0.011 104)", "45": "oklch(0.45 0.011 104)", "46": "oklch(0.46 0.011 104)", "47": "oklch(0.47 0.011 104)", "48": "oklch(0.48 0.011 104)", "49": "oklch(0.49 0.011 104)", "50": "oklch(0.5 0.011 104)", "51": "oklch(0.51 0.011 104)", "52": "oklch(0.52 0.011 104)", "53": "oklch(0.53 0.011 104)", "54": "oklch(0.54 0.011 104)", "55": "oklch(0.55 0.011 104)", "56": "oklch(0.56 0.011 104)", "57": "oklch(0.57 0.011 104)", "58": "oklch(0.58 0.011 104)", "59": "oklch(0.59 0.011 104)", "60": "oklch(0.6 0.011 104)", "61": "oklch(0.61 0.011 104)", "62": "oklch(0.62 0.011 104)", "63": "oklch(0.63 0.011 104)", "64": "oklch(0.64 0.011 104)", "65": "oklch(0.65 0.011 104)", "66": "oklch(0.66 0.011 104)", "67": "oklch(0.67 0.011 104)", "68": "oklch(0.68 0.011 104)", "69": "oklch(0.69 0.011 104)", "70": "oklch(0.7 0.011 104)", "71": "oklch(0.71 0.011 104)", "72": "oklch(0.72 0.011 104)", "73": "oklch(0.73 0.011 104)", "74": "oklch(0.74 0.011 104)", "75": "oklch(0.75 0.011 104)", "76": "oklch(0.76 0.011 104)", "77": "oklch(0.77 0.011 104)", "78": "oklch(0.78 0.011 104)", "79": "oklch(0.79 0.011 104)", "80": "oklch(0.8 0.011 104)", "81": "oklch(0.81 0.011 104)", "82": "oklch(0.82 0.011 104)", "83": "oklch(0.83 0.011 104)", "84": "oklch(0.84 0.011 104)", "85": "oklch(0.85 0.011 104)", "86": "oklch(0.86 0.011 104)", "87": "oklch(0.87 0.011 104)", "88": "oklch(0.88 0.011 104)", "89": "oklch(0.89 0.011 104)", "90": "oklch(0.9 0.011 104)", "91": "oklch(0.91 0.011 104)", "92": "oklch(0.92 0.011 104)", "93": "oklch(0.93 0.011 104)", "94": "oklch(0.94 0.011 104)", "95": "oklch(0.95 0.011 104)", "96": "oklch(0.96 0.011 104)", "97": "oklch(0.97 0.011 104)", "98": "oklch(0.98 0.011 104)"}, "grassland": {"10": "oklch(0.1 0.011 148)", "11": "oklch(0.11 0.011 148)", "12": "oklch(0.12 0.011 148)", "13": "oklch(0.13 0.011 148)", "14": "oklch(0.14 0.011 148)", "15": "oklch(0.15 0.011 148)", "16": "oklch(0.16 0.011 148)", "17": "oklch(0.17 0.011 148)", "18": "oklch(0.18 0.011 148)", "19": "oklch(0.19 0.011 148)", "20": "oklch(0.2 0.011 148)", "21": "oklch(0.21 0.011 148)", "22": "oklch(0.22 0.011 148)", "23": "oklch(0.23 0.011 148)", "24": "oklch(0.24 0.011 148)", "25": "oklch(0.25 0.011 148)", "26": "oklch(0.26 0.011 148)", "27": "oklch(0.27 0.011 148)", "28": "oklch(0.28 0.011 148)", "29": "oklch(0.29 0.011 148)", "30": "oklch(0.3 0.011 148)", "31": "oklch(0.31 0.011 148)", "32": "oklch(0.32 0.011 148)", "33": "oklch(0.33 0.011 148)", "34": "oklch(0.34 0.011 148)", "35": "oklch(0.35 0.011 148)", "36": "oklch(0.36 0.011 148)", "37": "oklch(0.37 0.011 148)", "38": "oklch(0.38 0.011 148)", "39": "oklch(0.39 0.011 148)", "40": "oklch(0.4 0.011 148)", "41": "oklch(0.41 0.011 148)", "42": "oklch(0.42 0.011 148)", "43": "oklch(0.43 0.011 148)", "44": "oklch(0.44 0.011 148)", "45": "oklch(0.45 0.011 148)", "46": "oklch(0.46 0.011 148)", "47": "oklch(0.47 0.011 148)", "48": "oklch(0.48 0.011 148)", "49": "oklch(0.49 0.011 148)", "50": "oklch(0.5 0.011 148)", "51": "oklch(0.51 0.011 148)", "52": "oklch(0.52 0.011 148)", "53": "oklch(0.53 0.011 148)", "54": "oklch(0.54 0.011 148)", "55": "oklch(0.55 0.011 148)", "56": "oklch(0.56 0.011 148)", "57": "oklch(0.57 0.011 148)", "58": "oklch(0.58 0.011 148)", "59": "oklch(0.59 0.011 148)", "60": "oklch(0.6 0.011 148)", "61": "oklch(0.61 0.011 148)", "62": "oklch(0.62 0.011 148)", "63": "oklch(0.63 0.011 148)", "64": "oklch(0.64 0.011 148)", "65": "oklch(0.65 0.011 148)", "66": "oklch(0.66 0.011 148)", "67": "oklch(0.67 0.011 148)", "68": "oklch(0.68 0.011 148)", "69": "oklch(0.69 0.011 148)", "70": "oklch(0.7 0.011 148)", "71": "oklch(0.71 0.011 148)", "72": "oklch(0.72 0.011 148)", "73": "oklch(0.73 0.011 148)", "74": "oklch(0.74 0.011 148)", "75": "oklch(0.75 0.011 148)", "76": "oklch(0.76 0.011 148)", "77": "oklch(0.77 0.011 148)", "78": "oklch(0.78 0.011 148)", "79": "oklch(0.79 0.011 148)", "80": "oklch(0.8 0.011 148)", "81": "oklch(0.81 0.011 148)", "82": "oklch(0.82 0.011 148)", "83": "oklch(0.83 0.011 148)", "84": "oklch(0.84 0.011 148)", "85": "oklch(0.85 0.011 148)", "86": "oklch(0.86 0.011 148)", "87": "oklch(0.87 0.011 148)", "88": "oklch(0.88 0.011 148)", "89": "oklch(0.89 0.011 148)", "90": "oklch(0.9 0.011 148)", "91": "oklch(0.91 0.011 148)", "92": "oklch(0.92 0.011 148)", "93": "oklch(0.93 0.011 148)", "94": "oklch(0.94 0.011 148)", "95": "oklch(0.95 0.011 148)", "96": "oklch(0.96 0.011 148)", "97": "oklch(0.97 0.011 148)", "98": "oklch(0.98 0.011 148)"}, "tundra": {"10": "oklch(0.1 0.011 262)", "11": "oklch(0.11 0.011 262)", "12": "oklch(0.12 0.011 262)", "13": "oklch(0.13 0.011 262)", "14": "oklch(0.14 0.011 262)", "15": "oklch(0.15 0.011 262)", "16": "oklch(0.16 0.011 262)", "17": "oklch(0.17 0.011 262)", "18": "oklch(0.18 0.011 262)", "19": "oklch(0.19 0.011 262)", "20": "oklch(0.2 0.011 262)", "21": "oklch(0.21 0.011 262)", "22": "oklch(0.22 0.011 262)", "23": "oklch(0.23 0.011 262)", "24": "oklch(0.24 0.011 262)", "25": "oklch(0.25 0.011 262)", "26": "oklch(0.26 0.011 262)", "27": "oklch(0.27 0.011 262)", "28": "oklch(0.28 0.011 262)", "29": "oklch(0.29 0.011 262)", "30": "oklch(0.3 0.011 262)", "31": "oklch(0.31 0.011 262)", "32": "oklch(0.32 0.011 262)", "33": "oklch(0.33 0.011 262)", "34": "oklch(0.34 0.011 262)", "35": "oklch(0.35 0.011 262)", "36": "oklch(0.36 0.011 262)", "37": "oklch(0.37 0.011 262)", "38": "oklch(0.38 0.011 262)", "39": "oklch(0.39 0.011 262)", "40": "oklch(0.4 0.011 262)", "41": "oklch(0.41 0.011 262)", "42": "oklch(0.42 0.011 262)", "43": "oklch(0.43 0.011 262)", "44": "oklch(0.44 0.011 262)", "45": "oklch(0.45 0.011 262)", "46": "oklch(0.46 0.011 262)", "47": "oklch(0.47 0.011 262)", "48": "oklch(0.48 0.011 262)", "49": "oklch(0.49 0.011 262)", "50": "oklch(0.5 0.011 262)", "51": "oklch(0.51 0.011 262)", "52": "oklch(0.52 0.011 262)", "53": "oklch(0.53 0.011 262)", "54": "oklch(0.54 0.011 262)", "55": "oklch(0.55 0.011 262)", "56": "oklch(0.56 0.011 262)", "57": "oklch(0.57 0.011 262)", "58": "oklch(0.58 0.011 262)", "59": "oklch(0.59 0.011 262)", "60": "oklch(0.6 0.011 262)", "61": "oklch(0.61 0.011 262)", "62": "oklch(0.62 0.011 262)", "63": "oklch(0.63 0.011 262)", "64": "oklch(0.64 0.011 262)", "65": "oklch(0.65 0.011 262)", "66": "oklch(0.66 0.011 262)", "67": "oklch(0.67 0.011 262)", "68": "oklch(0.68 0.011 262)", "69": "oklch(0.69 0.011 262)", "70": "oklch(0.7 0.011 262)", "71": "oklch(0.71 0.011 262)", "72": "oklch(0.72 0.011 262)", "73": "oklch(0.73 0.011 262)", "74": "oklch(0.74 0.011 262)", "75": "oklch(0.75 0.011 262)", "76": "oklch(0.76 0.011 262)", "77": "oklch(0.77 0.011 262)", "78": "oklch(0.78 0.011 262)", "79": "oklch(0.79 0.011 262)", "80": "oklch(0.8 0.011 262)", "81": "oklch(0.81 0.011 262)", "82": "oklch(0.82 0.011 262)", "83": "oklch(0.83 0.011 262)", "84": "oklch(0.84 0.011 262)", "85": "oklch(0.85 0.011 262)", "86": "oklch(0.86 0.011 262)", "87": "oklch(0.87 0.011 262)", "88": "oklch(0.88 0.011 262)", "89": "oklch(0.89 0.011 262)", "90": "oklch(0.9 0.011 262)", "91": "oklch(0.91 0.011 262)", "92": "oklch(0.92 0.011 262)", "93": "oklch(0.93 0.011 262)", "94": "oklch(0.94 0.011 262)", "95": "oklch(0.95 0.011 262)", "96": "oklch(0.96 0.011 262)", "97": "oklch(0.97 0.011 262)", "98": "oklch(0.98 0.00937 262)"}, "red": {"10": "oklch(0.1 0.04072 29)", "11": "oklch(0.11 0.04475 29)", "12": "oklch(0.12 0.04878 29)", "13": "oklch(0.13 0.05279 29)", "14": "oklch(0.14 0.0568 29)", "15": "oklch(0.15 0.0608 29)", "16": "oklch(0.16 0.06478 29)", "17": "oklch(0.17 0.06876 29)", "18": "oklch(0.18 0.07272 29)", "19": "oklch(0.19 0.07667 29)", "20": "oklch(0.2 0.08061 29)", "21": "oklch(0.21 0.08453 29)", "22": "oklch(0.22 0.08843 29)", "23": "oklch(0.23 0.09232 29)", "24": "oklch(0.24 0.09619 29)", "25": "oklch(0.25 0.10004 29)", "26": "oklch(0.26 0.10387 29)", "27": "oklch(0.27 0.10768 29)", "28": "oklch(0.28 0.11147 29)", "29": "oklch(0.29 0.11522 29)", "30": "oklch(0.3 0.11895 29)", "31": "oklch(0.31 0.12265 29)", "32": "oklch(0.32 0.12632 29)", "33": "oklch(0.33 0.12994 29)", "34": "oklch(0.34 0.13353 29)", "35": "oklch(0.35 0.13708 29)", "36": "oklch(0.36 0.14058 29)", "37": "oklch(0.37 0.14403 29)", "38": "oklch(0.38 0.14742 29)", "39": "oklch(0.39 0.15075 29)", "40": "oklch(0.4 0.15401 29)", "41": "oklch(0.41 0.1572 29)", "42": "oklch(0.42 0.1603 29)", "43": "oklch(0.43 0.16331 29)", "44": "oklch(0.44 0.16622 29)", "45": "oklch(0.45 0.16902 29)", "46": "oklch(0.46 0.17169 29)", "47": "oklch(0.47 0.17423 29)", "48": "oklch(0.48 0.17661 29)", "49": "oklch(0.49 0.17882 29)", "50": "oklch(0.5 0.18085 29)", "51": "oklch(0.51 0.18267 29)", "52": "oklch(0.52 0.18427 29)", "53": "oklch(0.53 0.18562 29)", "54": "oklch(0.54 0.18671 29)", "55": "oklch(0.55 0.1875 29)", "56": "oklch(0.56 0.18799 29)", "57": "oklch(0.57 0.18816 29)", "58": "oklch(0.58 0.18799 29)", "59": "oklch(0.59 0.18747 29)", "60": "oklch(0.6 0.18659 29)", "61": "oklch(0.61 0.18536 29)", "62": "oklch(0.62 0.18377 29)", "63": "oklch(0.63 0.18184 29)", "64": "oklch(0.64 0.17958 29)", "65": "oklch(0.65 0.177 29)", "66": "oklch(0.66 0.17412 29)", "67": "oklch(0.67 0.17096 29)", "68": "oklch(0.68 0.16754 29)", "69": "oklch(0.69 0.16388 29)", "70": "oklch(0.7 0.16001 29)", "71": "oklch(0.71 0.15594 29)", "72": "oklch(0.72 0.15169 29)", "73": "oklch(0.73 0.14728 29)", "74": "oklch(0.74 0.14272 29)", "75": "oklch(0.75 0.13803 29)", "76": "oklch(0.76 0.13322 29)", "77": "oklch(0.77 0.1283 29)", "78": "oklch(0.78 0.12329 29)", "79": "oklch(0.79 0.11818 29)", "80": "oklch(0.8 0.113 29)", "81": "oklch(0.81 0.10774 29)", "82": "oklch(0.82 0.10124 29)", "83": "oklch(0.83 0.09469 29)", "84": "oklch(0.84 0.08827 29)", "85": "oklch(0.85 0.08196 29)", "86": "oklch(0.86 0.07578 29)", "87": "oklch(0.87 0.06972 29)", "88": "oklch(0.88 0.06377 29)", "89": "oklch(0.89 0.05792 29)", "90": "oklch(0.9 0.05219 29)", "91": "oklch(0.91 0.04655 29)", "92": "oklch(0.92 0.04102 29)", "93": "oklch(0.93 0.03558 29)", "94": "oklch(0.94 0.03024 29)", "95": "oklch(0.95 0.02498 29)", "96": "oklch(0.96 0.01982 29)", "97": "oklch(0.97 0.01474 29)", "98": "oklch(0.98 0.00975 29)"}, "orange": {"10": "oklch(0.1 0.02282 62.5)", "11": "oklch(0.11 0.02508 62.5)", "12": "oklch(0.12 0.02735 62.5)", "13": "oklch(0.13 0.02962 62.5)", "14": "oklch(0.14 0.03188 62.5)", "15": "oklch(0.15 0.03413 62.5)", "16": "oklch(0.16 0.03639 62.5)", "17": "oklch(0.17 0.03864 62.5)", "18": "oklch(0.18 0.04089 62.5)", "19": "oklch(0.19 0.04314 62.5)", "20": "oklch(0.2 0.04538 62.5)", "21": "oklch(0.21 0.04761 62.5)", "22": "oklch(0.22 0.04985 62.5)", "23": "oklch(0.23 0.05208 62.5)", "24": "oklch(0.24 0.0543 62.5)", "25": "oklch(0.25 0.05652 62.5)", "26": "oklch(0.26 0.05873 62.5)", "27": "oklch(0.27 0.06094 62.5)", "28": "oklch(0.28 0.06314 62.5)", "29": "oklch(0.29 0.06534 62.5)", "30": "oklch(0.3 0.06753 62.5)", "31": "oklch(0.31 0.06971 62.5)", "32": "oklch(0.32 0.07189 62.5)", "33": "oklch(0.33 0.07406 62.5)", "34": "oklch(0.34 0.07622 62.5)", "35": "oklch(0.35 0.07837 62.5)", "36": "oklch(0.36 0.08051 62.5)", "37": "oklch(0.37 0.08265 62.5)", "38": "oklch(0.38 0.08477 62.5)", "39": "oklch(0.39 0.08688 62.5)", "40": "oklch(0.4 0.08898 62.5)", "41": "oklch(0.41 0.09106 62.5)", "42": "oklch(0.42 0.09313 62.5)", "43": "oklch(0.43 0.09519 62.5)", "44": "oklch(0.44 0.09723 62.5)", "45": "oklch(0.45 0.09925 62.5)", "46": "oklch(0.46 0.10125 62.5)", "47": "oklch(0.47 0.10324 62.5)", "48": "oklch(0.48 0.10519 62.5)", "49": "oklch(0.49 0.10713 62.5)", "50": "oklch(0.5 0.10904 62.5)", "51": "oklch(0.51 0.11091 62.5)", "52": "oklch(0.52 0.11276 62.5)", "53": "oklch(0.53 0.11457 62.5)", "54": "oklch(0.54 0.11634 62.5)", "55": "oklch(0.55 0.11807 62.5)", "56": "oklch(0.56 0.11975 62.5)", "57": "oklch(0.57 0.12138 62.5)", "58": "oklch(0.58 0.12295 62.5)", "59": "oklch(0.59 0.12446 62.5)", "60": "oklch(0.6 0.12589 62.5)", "61": "oklch(0.61 0.12724 62.5)", "62": "oklch(0.62 0.1285 62.5)", "63": "oklch(0.63 0.12966 62.5)", "64": "oklch(0.64 0.1307 62.5)", "65": "oklch(0.65 0.13161 62.5)", "66": "oklch(0.66 0.13238 62.5)", "67": "oklch(0.67 0.13298 62.5)", "68": "oklch(0.68 0.13341 62.5)", "69": "oklch(0.69 0.13362 62.5)", "70": "oklch(0.7 0.13361 62.5)", "71": "oklch(0.71 0.13334 62.5)", "72": "oklch(0.72 0.13279 62.5)", "73": "oklch(0.73 0.13193 62.5)", "74": "oklch(0.74 0.13074 62.5)", "75": "oklch(0.75 0.1292 62.5)", "76": "oklch(0.76 0.12729 62.5)", "77": "oklch(0.77 0.125 62.5)", "78": "oklch(0.78 0.12232 62.5)", "79": "oklch(0.79 0.11926 62.5)", "80": "oklch(0.8 0.11582 62.5)", "81": "oklch(0.81 0.11202 62.5)", "82": "oklch(0.82 0.10788 62.5)", "83": "oklch(0.83 0.10342 62.5)", "84": "oklch(0.84 0.09867 62.5)", "85": "oklch(0.85 0.09365 62.5)", "86": "oklch(0.86 0.08839 62.5)", "87": "oklch(0.87 0.08292 62.5)", "88": "oklch(0.88 0.07725 62.5)", "89": "oklch(0.89 0.07141 62.5)", "90": "oklch(0.9 0.06542 62.5)", "91": "oklch(0.91 0.05929 62.5)", "92": "oklch(0.92 0.05282 62.5)", "93": "oklch(0.93 0.04589 62.5)", "94": "oklch(0.94 0.03905 62.5)", "95": "oklch(0.95 0.03232 62.5)", "96": "oklch(0.96 0.02567 62.5)", "97": "oklch(0.97 0.01912 62.5)", "98": "oklch(0.98 0.01266 62.5)"}, "yellow": {"10": "oklch(0.1 0.0198 104)", "11": "oklch(0.11 0.02164 104)", "12": "oklch(0.12 0.02345 104)", "13": "oklch(0.13 0.02523 104)", "14": "oklch(0.14 0.02699 104)", "15": "oklch(0.15 0.02873 104)", "16": "oklch(0.16 0.03043 104)", "17": "oklch(0.17 0.03212 104)", "18": "oklch(0.18 0.03377 104)", "19": "oklch(0.19 0.0354 104)", "20": "oklch(0.2 0.037 104)", "21": "oklch(0.21 0.03858 104)", "22": "oklch(0.22 0.04013 104)", "23": "oklch(0.23 0.04165 104)", "24": "oklch(0.24 0.04315 104)", "25": "oklch(0.25 0.04462 104)", "26": "oklch(0.26 0.04606 104)", "27": "oklch(0.27 0.04748 104)", "28": "oklch(0.28 0.04887 104)", "29": "oklch(0.29 0.05023 104)", "30": "oklch(0.3 0.05156 104)", "31": "oklch(0.31 0.05287 104)", "32": "oklch(0.32 0.05415 104)", "33": "oklch(0.33 0.0554 104)", "34": "oklch(0.34 0.05662 104)", "35": "oklch(0.35 0.05782 104)", "36": "oklch(0.36 0.05898 104)", "37": "oklch(0.37 0.06012 104)", "38": "oklch(0.38 0.06122 104)", "39": "oklch(0.39 0.0623 104)", "40": "oklch(0.4 0.06335 104)", "41": "oklch(0.41 0.06436 104)", "42": "oklch(0.42 0.06535 104)", "43": "oklch(0.43 0.0663 104)", "44": "oklch(0.44 0.06722 104)", "45": "oklch(0.45 0.06811 104)", "46": "oklch(0.46 0.06897 104)", "47": "oklch(0.47 0.06979 104)", "48": "oklch(0.48 0.07058 104)", "49": "oklch(0.49 0.07134 104)", "50": "oklch(0.5 0.07206 104)", "51": "oklch(0.51 0.07275 104)", "52": "oklch(0.52 0.0734 104)", "53": "oklch(0.53 0.07401 104)", "54": "oklch(0.54 0.07459 104)", "55": "oklch(0.55 0.07513 104)", "56": "oklch(0.56 0.07563 104)", "57": "oklch(0.57 0.07609 104)", "58": "oklch(0.58 0.07651 104)", "59": "oklch(0.59 0.07688 104)", "60": "oklch(0.6 0.07722 104)", "61": "oklch(0.61 0.07751 104)", "62": "oklch(0.62 0.07775 104)", "63": "oklch(0.63 0.07795 104)", "64": "oklch(0.64 0.0781 104)", "65": "oklch(0.65 0.0782 104)", "66": "oklch(0.66 0.07825 104)", "67": "oklch(0.67 0.07825 104)", "68": "oklch(0.68 0.07819 104)", "69": "oklch(0.69 0.07808 104)", "70": "oklch(0.7 0.07791 104)", "71": "oklch(0.71 0.07768 104)", "72": "oklch(0.72 0.07739 104)", "73": "oklch(0.73 0.07703 104)", "74": "oklch(0.74 0.0766 104)", "75": "oklch(0.75 0.0761 104)", "76": "oklch(0.76 0.07553 104)", "77": "oklch(0.77 0.07487 104)", "78": "oklch(0.78 0.07414 104)", "79": "oklch(0.79 0.07331 104)", "80": "oklch(0.8 0.07239 104)", "81": "oklch(0.81 0.07137 104)", "82": "oklch(0.82 0.07025 104)", "83": "oklch(0.83 0.06901 104)", "84": "oklch(0.84 0.06765 104)", "85": "oklch(0.85 0.06616 104)", "86": "oklch(0.86 0.06452 104)", "87": "oklch(0.87 0.06273 104)", "88": "oklch(0.88 0.06076 104)", "89": "oklch(0.89 0.05859 104)", "90": "oklch(0.9 0.05621 104)", "91": "oklch(0.91 0.05359 104)", "92": "oklch(0.92 0.05067 104)", "93": "oklch(0.93 0.04743 104)", "94": "oklch(0.94 0.04378 104)", "95": "oklch(0.95 0.03965 104)", "96": "oklch(0.96 0.03489 104)", "97": "oklch(0.97 0.0293 104)", "98": "oklch(0.98 0.02248 104)"}, "green": {"10": "oklch(0.1 0.02779 148)", "11": "oklch(0.11 0.03043 148)", "12": "oklch(0.12 0.03305 148)", "13": "oklch(0.13 0.03564 148)", "14": "oklch(0.14 0.03821 148)", "15": "oklch(0.15 0.04075 148)", "16": "oklch(0.16 0.04326 148)", "17": "oklch(0.17 0.04575 148)", "18": "oklch(0.18 0.0482 148)", "19": "oklch(0.19 0.05063 148)", "20": "oklch(0.2 0.05303 148)", "21": "oklch(0.21 0.0554 148)", "22": "oklch(0.22 0.05774 148)", "23": "oklch(0.23 0.06006 148)", "24": "oklch(0.24 0.06233 148)", "25": "oklch(0.25 0.06458 148)", "26": "oklch(0.26 0.0668 148)", "27": "oklch(0.27 0.06898 148)", "28": "oklch(0.28 0.07113 148)", "29": "oklch(0.29 0.07325 148)", "30": "oklch(0.3 0.07534 148)", "31": "oklch(0.31 0.07738 148)", "32": "oklch(0.32 0.0794 148)", "33": "oklch(0.33 0.08137 148)", "34": "oklch(0.34 0.08331 148)", "35": "oklch(0.35 0.08522 148)", "36": "oklch(0.36 0.08708 148)", "37": "oklch(0.37 0.08891 148)", "38": "oklch(0.38 0.09069 148)", "39": "oklch(0.39 0.09244 148)", "40": "oklch(0.4 0.09414 148)", "41": "oklch(0.41 0.0958 148)", "42": "oklch(0.42 0.09742 148)", "43": "oklch(0.43 0.09899 148)", "44": "oklch(0.44 0.10052 148)", "45": "oklch(0.45 0.102 148)", "46": "oklch(0.46 0.10343 148)", "47": "oklch(0.47 0.10481 148)", "48": "oklch(0.48 0.10615 148)", "49": "oklch(0.49 0.10743 148)", "50": "oklch(0.5 0.10866 148)", "51": "oklch(0.51 0.10984 148)", "52": "oklch(0.52 0.11096 148)", "53": "oklch(0.53 0.11202 148)", "54": "oklch(0.54 0.11302 148)", "55": "oklch(0.55 0.11397 148)", "56": "oklch(0.56 0.11485 148)", "57": "oklch(0.57 0.11567 148)", "58": "oklch(0.58 0.11643 148)", "59": "oklch(0.59 0.11711 148)", "60": "oklch(0.6 0.11773 148)", "61": "oklch(0.61 0.11827 148)", "62": "oklch(0.62 0.11874 148)", "63": "oklch(0.63 0.11913 148)", "64": "oklch(0.64 0.11944 148)", "65": "oklch(0.65 0.11966 148)", "66": "oklch(0.66 0.1198 148)", "67": "oklch(0.67 0.11986 148)", "68": "oklch(0.68 0.11981 148)", "69": "oklch(0.69 0.11967 148)", "70": "oklch(0.7 0.11943 148)", "71": "oklch(0.71 0.11909 148)", "72": "oklch(0.72 0.11863 148)", "73": "oklch(0.73 0.11805 148)", "74": "oklch(0.74 0.11736 148)", "75": "oklch(0.75 0.11654 148)", "76": "oklch(0.76 0.11558 148)", "77": "oklch(0.77 0.11448 148)", "78": "oklch(0.78 0.11324 148)", "79": "oklch(0.79 0.11183 148)", "80": "oklch(0.8 0.11026 148)", "81": "oklch(0.81 0.10851 148)", "82": "oklch(0.82 0.10656 148)", "83": "oklch(0.83 0.10441 148)", "84": "oklch(0.84 0.10205 148)", "85": "oklch(0.85 0.09944 148)", "86": "oklch(0.86 0.09658 148)", "87": "oklch(0.87 0.09344 148)", "88": "oklch(0.88 0.08999 148)", "89": "oklch(0.89 0.08621 148)", "90": "oklch(0.9 0.08205 148)", "91": "oklch(0.91 0.07747 148)", "92": "oklch(0.92 0.07242 148)", "93": "oklch(0.93 0.06684 148)", "94": "oklch(0.94 0.06063 148)", "95": "oklch(0.95 0.0537 148)", "96": "oklch(0.96 0.04588 148)", "97": "oklch(0.97 0.037 148)", "98": "oklch(0.98 0.02675 148)"}, "blue": {"10": "oklch(0.1 0.04146 262)", "11": "oklch(0.11 0.04518 262)", "12": "oklch(0.12 0.04882 262)", "13": "oklch(0.13 0.05238 262)", "14": "oklch(0.14 0.05587 262)", "15": "oklch(0.15 0.05927 262)", "16": "oklch(0.16 0.06259 262)", "17": "oklch(0.17 0.06583 262)", "18": "oklch(0.18 0.06898 262)", "19": "oklch(0.19 0.07206 262)", "20": "oklch(0.2 0.07505 262)", "21": "oklch(0.21 0.07796 262)", "22": "oklch(0.22 0.08079 262)", "23": "oklch(0.23 0.08353 262)", "24": "oklch(0.24 0.08619 262)", "25": "oklch(0.25 0.08877 262)", "26": "oklch(0.26 0.09125 262)", "27": "oklch(0.27 0.09366 262)", "28": "oklch(0.28 0.09598 262)", "29": "oklch(0.29 0.09821 262)", "30": "oklch(0.3 0.10035 262)", "31": "oklch(0.31 0.10241 262)", "32": "oklch(0.32 0.10437 262)", "33": "oklch(0.33 0.10625 262)", "34": "oklch(0.34 0.10804 262)", "35": "oklch(0.35 0.10975 262)", "36": "oklch(0.36 0.11136 262)", "37": "oklch(0.37 0.11288 262)", "38": "oklch(0.38 0.11431 262)", "39": "oklch(0.39 0.11565 262)", "40": "oklch(0.4 0.11689 262)", "41": "oklch(0.41 0.11805 262)", "42": "oklch(0.42 0.11911 262)", "43": "oklch(0.43 0.12007 262)", "44": "oklch(0.44 0.12095 262)", "45": "oklch(0.45 0.12172 262)", "46": "oklch(0.46 0.12241 262)", "47": "oklch(0.47 0.12299 262)", "48": "oklch(0.48 0.12348 262)", "49": "oklch(0.49 0.12388 262)", "50": "oklch(0.5 0.12417 262)", "51": "oklch(0.51 0.12437 262)", "52": "oklch(0.52 0.12447 262)", "53": "oklch(0.53 0.12447 262)", "54": "oklch(0.54 0.12437 262)", "55": "oklch(0.55 0.12417 262)", "56": "oklch(0.56 0.12387 262)", "57": "oklch(0.57 0.12347 262)", "58": "oklch(0.58 0.12296 262)", "59": "oklch(0.59 0.12235 262)", "60": "oklch(0.6 0.12164 262)", "61": "oklch(0.61 0.12082 262)", "62": "oklch(0.62 0.1199 262)", "63": "oklch(0.63 0.11887 262)", "64": "oklch(0.64 0.11774 262)", "65": "oklch(0.65 0.1165 262)", "66": "oklch(0.66 0.11515 262)", "67": "oklch(0.67 0.1137 262)", "68": "oklch(0.68 0.11213 262)", "69": "oklch(0.69 0.11046 262)", "70": "oklch(0.7 0.10868 262)", "71": "oklch(0.71 0.10678 262)", "72": "oklch(0.72 0.10477 262)", "73": "oklch(0.73 0.10265 262)", "74": "oklch(0.74 0.10042 262)", "75": "oklch(0.75 0.09807 262)", "76": "oklch(0.76 0.09561 262)", "77": "oklch(0.77 0.09303 262)", "78": "oklch(0.78 0.09034 262)", "79": "oklch(0.79 0.08753 262)", "80": "oklch(0.8 0.0846 262)", "81": "oklch(0.81 0.08155 262)", "82": "oklch(0.82 0.07839 262)", "83": "oklch(0.83 0.0751 262)", "84": "oklch(0.84 0.07169 262)", "85": "oklch(0.85 0.06816 262)", "86": "oklch(0.86 0.06451 262)", "87": "oklch(0.87 0.06074 262)", "88": "oklch(0.88 0.05684 262)", "89": "oklch(0.89 0.05281 262)", "90": "oklch(0.9 0.04833 262)", "91": "oklch(0.91 0.04332 262)", "92": "oklch(0.92 0.03836 262)", "93": "oklch(0.93 0.03343 262)", "94": "oklch(0.94 0.02854 262)", "95": "oklch(0.95 0.02369 262)", "96": "oklch(0.96 0.01888 262)", "97": "oklch(0.97 0.01411 262)", "98": "oklch(0.98 0.00937 262)"}} \ No newline at end of file diff --git a/notebooks/palettes/monobiome-vQBR.toml b/notebooks/palettes/monobiome-vQBR.toml new file mode 100644 index 0000000..6668d24 --- /dev/null +++ b/notebooks/palettes/monobiome-vQBR.toml @@ -0,0 +1,1000 @@ +[alpine] +l10 = "#030303" +l11 = "#040404" +l12 = "#060606" +l13 = "#070707" +l14 = "#090909" +l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" +l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" +l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" +l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" +l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" +l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" +l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" +l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" +l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" +l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" +l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" +l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" +l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" +l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" +l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" +l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" +l95 = "#eeeeee" +l96 = "#f2f2f2" +l97 = "#f5f5f5" +l98 = "#f8f8f8" + +[badlands] +l10 = "#060302" +l11 = "#070303" +l12 = "#090504" +l13 = "#0b0605" +l14 = "#0d0807" +l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" +l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" +l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" +l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" +l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" +l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" +l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" +l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" +l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" +l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" +l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" +l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" +l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" +l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" +l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" +l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" +l95 = "#f6ecea" +l96 = "#f9efee" +l97 = "#fcf3f1" +l98 = "#fff6f5" + +[chaparral] +l10 = "#050301" +l11 = "#070402" +l12 = "#080503" +l13 = "#0a0704" +l14 = "#0c0805" +l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" +l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" +l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" +l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" +l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" +l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" +l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" +l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" +l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" +l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" +l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" +l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" +l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" +l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" +l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" +l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" +l95 = "#f4ede7" +l96 = "#f7f0ea" +l97 = "#fbf4ee" +l98 = "#fef7f1" + +[savanna] +l10 = "#040301" +l11 = "#050502" +l12 = "#060603" +l13 = "#080704" +l14 = "#0a0905" +l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" +l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" +l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" +l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" +l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" +l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" +l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" +l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" +l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" +l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" +l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" +l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" +l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" +l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" +l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" +l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" +l95 = "#efefe7" +l96 = "#f3f2ea" +l97 = "#f6f6ed" +l98 = "#f9f9f1" + +[grassland] +l10 = "#020402" +l11 = "#030503" +l12 = "#040704" +l13 = "#050805" +l14 = "#060a07" +l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" +l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" +l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" +l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" +l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" +l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" +l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" +l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" +l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" +l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" +l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" +l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" +l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" +l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" +l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" +l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" +l95 = "#eaf1ea" +l96 = "#edf4ee" +l97 = "#f0f7f1" +l98 = "#f4fbf4" + +[tundra] +l10 = "#020306" +l11 = "#030408" +l12 = "#040609" +l13 = "#05070c" +l14 = "#07090e" +l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" +l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" +l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" +l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" +l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" +l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" +l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" +l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" +l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" +l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" +l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" +l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" +l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" +l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" +l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" +l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" +l95 = "#eaeff6" +l96 = "#eef2f9" +l97 = "#f1f5fd" +l98 = "#f5f9ff" + +[red] +l10 = "#0d0000" +l11 = "#100000" +l12 = "#140000" +l13 = "#170000" +l14 = "#1b0000" +l15 = "#1f0000" +l16 = "#220000" +l17 = "#260000" +l18 = "#2a0000" +l19 = "#2e0000" +l20 = "#320100" +l21 = "#360101" +l22 = "#3a0101" +l23 = "#3e0101" +l24 = "#420101" +l25 = "#460101" +l26 = "#4a0201" +l27 = "#4f0202" +l28 = "#530302" +l29 = "#570302" +l30 = "#5c0302" +l31 = "#600403" +l32 = "#640503" +l33 = "#690604" +l34 = "#6d0604" +l35 = "#710805" +l36 = "#760906" +l37 = "#7a0a07" +l38 = "#7f0b07" +l39 = "#830d09" +l40 = "#880f0a" +l41 = "#8c100b" +l42 = "#91120d" +l43 = "#95140e" +l44 = "#991610" +l45 = "#9e1811" +l46 = "#a21a13" +l47 = "#a71c15" +l48 = "#ab1f17" +l49 = "#af2119" +l50 = "#b3241b" +l51 = "#b8261d" +l52 = "#bc291f" +l53 = "#c02c22" +l54 = "#c42f25" +l55 = "#c83327" +l56 = "#cb362a" +l57 = "#cf3a2d" +l58 = "#d23d31" +l59 = "#d64134" +l60 = "#d94538" +l61 = "#dc493b" +l62 = "#df4e3f" +l63 = "#e25243" +l64 = "#e45647" +l65 = "#e75b4c" +l66 = "#e95f50" +l67 = "#ec6454" +l68 = "#ee6959" +l69 = "#f06d5d" +l70 = "#f17262" +l71 = "#f37767" +l72 = "#f57b6c" +l73 = "#f68070" +l74 = "#f88575" +l75 = "#f98a7a" +l76 = "#fa8e7f" +l77 = "#fb9384" +l78 = "#fc9889" +l79 = "#fd9d8e" +l80 = "#fea194" +l81 = "#ffa699" +l82 = "#ffab9e" +l83 = "#ffb0a4" +l84 = "#ffb5aa" +l85 = "#ffbaaf" +l86 = "#ffbfb5" +l87 = "#ffc4ba" +l88 = "#ffc8c0" +l89 = "#ffcdc5" +l90 = "#ffd2ca" +l91 = "#ffd6d0" +l92 = "#ffdbd5" +l93 = "#ffe0da" +l94 = "#ffe4e0" +l95 = "#ffe9e5" +l96 = "#ffedea" +l97 = "#fff2ef" +l98 = "#fff6f5" + +[orange] +l10 = "#070200" +l11 = "#0a0300" +l12 = "#0c0400" +l13 = "#0f0500" +l14 = "#120600" +l15 = "#150700" +l16 = "#180900" +l17 = "#1b0b00" +l18 = "#1e0d00" +l19 = "#210f00" +l20 = "#241100" +l21 = "#271200" +l22 = "#2a1400" +l23 = "#2e1600" +l24 = "#311800" +l25 = "#341a00" +l26 = "#381c01" +l27 = "#3b1e01" +l28 = "#3e2101" +l29 = "#422301" +l30 = "#452501" +l31 = "#492701" +l32 = "#4c2901" +l33 = "#502b02" +l34 = "#532d02" +l35 = "#573002" +l36 = "#5a3203" +l37 = "#5e3403" +l38 = "#613603" +l39 = "#653904" +l40 = "#693b04" +l41 = "#6c3d05" +l42 = "#704005" +l43 = "#744206" +l44 = "#784407" +l45 = "#7b4708" +l46 = "#7f4909" +l47 = "#834c0a" +l48 = "#874e0b" +l49 = "#8a500c" +l50 = "#8e530e" +l51 = "#92550f" +l52 = "#965810" +l53 = "#9a5a12" +l54 = "#9d5d13" +l55 = "#a16015" +l56 = "#a56217" +l57 = "#a96518" +l58 = "#ad671a" +l59 = "#b06a1c" +l60 = "#b46d1e" +l61 = "#b86f20" +l62 = "#bc7222" +l63 = "#c07525" +l64 = "#c37827" +l65 = "#c77b2a" +l66 = "#ca7e2d" +l67 = "#ce8130" +l68 = "#d28433" +l69 = "#d58736" +l70 = "#d88a3a" +l71 = "#dc8d3e" +l72 = "#df9042" +l73 = "#e29346" +l74 = "#e5974b" +l75 = "#e79a50" +l76 = "#ea9e55" +l77 = "#eda15a" +l78 = "#efa560" +l79 = "#f1a966" +l80 = "#f3ad6c" +l81 = "#f5b172" +l82 = "#f6b479" +l83 = "#f8b880" +l84 = "#f9bc87" +l85 = "#fac18e" +l86 = "#fbc595" +l87 = "#fcc99c" +l88 = "#fdcda3" +l89 = "#fed1ab" +l90 = "#fed5b2" +l91 = "#ffd9ba" +l92 = "#ffdec1" +l93 = "#ffe2c9" +l94 = "#ffe6d1" +l95 = "#ffead9" +l96 = "#ffefe1" +l97 = "#fff3e8" +l98 = "#fff7f0" + +[yellow] +l10 = "#040300" +l11 = "#050500" +l12 = "#070600" +l13 = "#090800" +l14 = "#0b0901" +l15 = "#0d0c01" +l16 = "#0f0e01" +l17 = "#121001" +l18 = "#141202" +l19 = "#161402" +l20 = "#191702" +l21 = "#1b1903" +l22 = "#1e1b04" +l23 = "#201e04" +l24 = "#232005" +l25 = "#252306" +l26 = "#282507" +l27 = "#2a2708" +l28 = "#2d2a0a" +l29 = "#302c0b" +l30 = "#322f0c" +l31 = "#35310e" +l32 = "#373410" +l33 = "#3a3711" +l34 = "#3d3913" +l35 = "#403c14" +l36 = "#423f16" +l37 = "#454118" +l38 = "#48441a" +l39 = "#4b471b" +l40 = "#4d491d" +l41 = "#504c1f" +l42 = "#534f21" +l43 = "#565223" +l44 = "#595425" +l45 = "#5c5727" +l46 = "#5e5a29" +l47 = "#615d2b" +l48 = "#64602d" +l49 = "#676230" +l50 = "#6a6532" +l51 = "#6d6834" +l52 = "#706b36" +l53 = "#736e39" +l54 = "#76713b" +l55 = "#79743e" +l56 = "#7c7740" +l57 = "#7f7a43" +l58 = "#827d45" +l59 = "#858048" +l60 = "#88834a" +l61 = "#8b864d" +l62 = "#8e8950" +l63 = "#918c52" +l64 = "#948f55" +l65 = "#979258" +l66 = "#9a955b" +l67 = "#9d985e" +l68 = "#a09b61" +l69 = "#a39e64" +l70 = "#a6a167" +l71 = "#a9a46b" +l72 = "#aca76e" +l73 = "#afab71" +l74 = "#b2ae74" +l75 = "#b6b178" +l76 = "#b9b47b" +l77 = "#bcb77f" +l78 = "#bfba83" +l79 = "#c2bd86" +l80 = "#c5c18a" +l81 = "#c8c48e" +l82 = "#cbc792" +l83 = "#ceca96" +l84 = "#d1cd9a" +l85 = "#d4d19e" +l86 = "#d7d4a3" +l87 = "#dbd7a7" +l88 = "#dedaac" +l89 = "#e1ddb1" +l90 = "#e4e1b6" +l91 = "#e7e4bb" +l92 = "#eae7c0" +l93 = "#edeac6" +l94 = "#f0edcc" +l95 = "#f2f0d2" +l96 = "#f5f3d9" +l97 = "#f8f7e0" +l98 = "#fbfae8" + +[green] +l10 = "#000501" +l11 = "#000701" +l12 = "#000801" +l13 = "#000b02" +l14 = "#000d02" +l15 = "#011003" +l16 = "#011203" +l17 = "#011504" +l18 = "#011705" +l19 = "#021a06" +l20 = "#021c07" +l21 = "#031f08" +l22 = "#03210a" +l23 = "#04240b" +l24 = "#04270d" +l25 = "#052a0e" +l26 = "#062c10" +l27 = "#072f11" +l28 = "#083213" +l29 = "#0a3515" +l30 = "#0b3816" +l31 = "#0d3a18" +l32 = "#0e3d1a" +l33 = "#10401b" +l34 = "#11431d" +l35 = "#13461f" +l36 = "#154921" +l37 = "#164c23" +l38 = "#184f25" +l39 = "#1a5227" +l40 = "#1c5529" +l41 = "#1d582a" +l42 = "#1f5b2d" +l43 = "#215e2f" +l44 = "#236131" +l45 = "#256433" +l46 = "#276735" +l47 = "#296a37" +l48 = "#2c6d39" +l49 = "#2e713c" +l50 = "#30743e" +l51 = "#327740" +l52 = "#357a42" +l53 = "#377d45" +l54 = "#398047" +l55 = "#3c834a" +l56 = "#3e864c" +l57 = "#418a4f" +l58 = "#448d51" +l59 = "#469054" +l60 = "#499356" +l61 = "#4c9659" +l62 = "#4e995c" +l63 = "#519d5f" +l64 = "#54a061" +l65 = "#57a364" +l66 = "#5aa667" +l67 = "#5da96a" +l68 = "#60ac6d" +l69 = "#64b070" +l70 = "#67b373" +l71 = "#6ab676" +l72 = "#6eb97a" +l73 = "#71bc7d" +l74 = "#75bf80" +l75 = "#78c283" +l76 = "#7cc587" +l77 = "#80c88a" +l78 = "#83cb8e" +l79 = "#87cf92" +l80 = "#8bd295" +l81 = "#8fd499" +l82 = "#94d79d" +l83 = "#98daa1" +l84 = "#9cdda5" +l85 = "#a1e0a9" +l86 = "#a6e3ad" +l87 = "#aae6b2" +l88 = "#afe8b6" +l89 = "#b4ebbb" +l90 = "#baeec0" +l91 = "#bff0c5" +l92 = "#c5f3ca" +l93 = "#cbf5cf" +l94 = "#d1f7d5" +l95 = "#d7f9db" +l96 = "#defbe1" +l97 = "#e5fde7" +l98 = "#edfeef" + +[blue] +l10 = "#000211" +l11 = "#000314" +l12 = "#000418" +l13 = "#01061c" +l14 = "#010720" +l15 = "#010924" +l16 = "#010b27" +l17 = "#020d2b" +l18 = "#020f2f" +l19 = "#021133" +l20 = "#031337" +l21 = "#04153b" +l22 = "#04173f" +l23 = "#051943" +l24 = "#061c47" +l25 = "#071e4b" +l26 = "#09204f" +l27 = "#0a2353" +l28 = "#0c2557" +l29 = "#0d285b" +l30 = "#0f2a5f" +l31 = "#112d63" +l32 = "#132f67" +l33 = "#14326b" +l34 = "#16346f" +l35 = "#183773" +l36 = "#1a3977" +l37 = "#1c3c7a" +l38 = "#1e3f7e" +l39 = "#204182" +l40 = "#224486" +l41 = "#254789" +l42 = "#274a8d" +l43 = "#294c91" +l44 = "#2b4f94" +l45 = "#2e5298" +l46 = "#30559b" +l47 = "#33589f" +l48 = "#355ba2" +l49 = "#385ea6" +l50 = "#3a61a9" +l51 = "#3d63ad" +l52 = "#4066b0" +l53 = "#4269b3" +l54 = "#456cb6" +l55 = "#486fba" +l56 = "#4b72bd" +l57 = "#4e75c0" +l58 = "#5179c3" +l59 = "#547cc6" +l60 = "#577fc9" +l61 = "#5a82cb" +l62 = "#5e85ce" +l63 = "#6188d1" +l64 = "#648bd4" +l65 = "#678ed6" +l66 = "#6b91d9" +l67 = "#6e95db" +l68 = "#7298de" +l69 = "#759be0" +l70 = "#799ee2" +l71 = "#7da1e4" +l72 = "#80a5e7" +l73 = "#84a8e9" +l74 = "#88abeb" +l75 = "#8caeed" +l76 = "#90b1ee" +l77 = "#94b5f0" +l78 = "#98b8f2" +l79 = "#9cbbf3" +l80 = "#a0bef5" +l81 = "#a4c2f6" +l82 = "#a9c5f8" +l83 = "#adc8f9" +l84 = "#b1cbfa" +l85 = "#b6cffb" +l86 = "#bad2fc" +l87 = "#bfd5fd" +l88 = "#c3d8fe" +l89 = "#c8dcff" +l90 = "#cddfff" +l91 = "#d2e2ff" +l92 = "#d7e5ff" +l93 = "#dce9ff" +l94 = "#e1ecff" +l95 = "#e6efff" +l96 = "#ebf2ff" +l97 = "#f0f5ff" +l98 = "#f5f9ff" diff --git a/notebooks/palettes/monobiome-vQBRsn-oklch.json b/notebooks/palettes/monobiome-vQBRsn-oklch.json new file mode 100644 index 0000000..d12d88d --- /dev/null +++ b/notebooks/palettes/monobiome-vQBRsn-oklch.json @@ -0,0 +1 @@ +{"alpine": {"10": "oklch(10.0% 0.0000 0.0)", "11": "oklch(11.0% 0.0000 0.0)", "12": "oklch(12.0% 0.0000 0.0)", "13": "oklch(13.0% 0.0000 0.0)", "14": "oklch(14.0% 0.0000 0.0)", "15": "oklch(15.0% 0.0000 0.0)", "16": "oklch(16.0% 0.0000 0.0)", "17": "oklch(17.0% 0.0000 0.0)", "18": "oklch(18.0% 0.0000 0.0)", "19": "oklch(19.0% 0.0000 0.0)", "20": "oklch(20.0% 0.0000 0.0)", "21": "oklch(21.0% 0.0000 0.0)", "22": "oklch(22.0% 0.0000 0.0)", "23": "oklch(23.0% 0.0000 0.0)", "24": "oklch(24.0% 0.0000 0.0)", "25": "oklch(25.0% 0.0000 0.0)", "26": "oklch(26.0% 0.0000 0.0)", "27": "oklch(27.0% 0.0000 0.0)", "28": "oklch(28.0% 0.0000 0.0)", "29": "oklch(29.0% 0.0000 0.0)", "30": "oklch(30.0% 0.0000 0.0)", "31": "oklch(31.0% 0.0000 0.0)", "32": "oklch(32.0% 0.0000 0.0)", "33": "oklch(33.0% 0.0000 0.0)", "34": "oklch(34.0% 0.0000 0.0)", "35": "oklch(35.0% 0.0000 0.0)", "36": "oklch(36.0% 0.0000 0.0)", "37": "oklch(37.0% 0.0000 0.0)", "38": "oklch(38.0% 0.0000 0.0)", "39": "oklch(39.0% 0.0000 0.0)", "40": "oklch(40.0% 0.0000 0.0)", "41": "oklch(41.0% 0.0000 0.0)", "42": "oklch(42.0% 0.0000 0.0)", "43": "oklch(43.0% 0.0000 0.0)", "44": "oklch(44.0% 0.0000 0.0)", "45": "oklch(45.0% 0.0000 0.0)", "46": "oklch(46.0% 0.0000 0.0)", "47": "oklch(47.0% 0.0000 0.0)", "48": "oklch(48.0% 0.0000 0.0)", "49": "oklch(49.0% 0.0000 0.0)", "50": "oklch(50.0% 0.0000 0.0)", "51": "oklch(51.0% 0.0000 0.0)", "52": "oklch(52.0% 0.0000 0.0)", "53": "oklch(53.0% 0.0000 0.0)", "54": "oklch(54.0% 0.0000 0.0)", "55": "oklch(55.0% 0.0000 0.0)", "56": "oklch(56.0% 0.0000 0.0)", "57": "oklch(57.0% 0.0000 0.0)", "58": "oklch(58.0% 0.0000 0.0)", "59": "oklch(59.0% 0.0000 0.0)", "60": "oklch(60.0% 0.0000 0.0)", "61": "oklch(61.0% 0.0000 0.0)", "62": "oklch(62.0% 0.0000 0.0)", "63": "oklch(63.0% 0.0000 0.0)", "64": "oklch(64.0% 0.0000 0.0)", "65": "oklch(65.0% 0.0000 0.0)", "66": "oklch(66.0% 0.0000 0.0)", "67": "oklch(67.0% 0.0000 0.0)", "68": "oklch(68.0% 0.0000 0.0)", "69": "oklch(69.0% 0.0000 0.0)", "70": "oklch(70.0% 0.0000 0.0)", "71": "oklch(71.0% 0.0000 0.0)", "72": "oklch(72.0% 0.0000 0.0)", "73": "oklch(73.0% 0.0000 0.0)", "74": "oklch(74.0% 0.0000 0.0)", "75": "oklch(75.0% 0.0000 0.0)", "76": "oklch(76.0% 0.0000 0.0)", "77": "oklch(77.0% 0.0000 0.0)", "78": "oklch(78.0% 0.0000 0.0)", "79": "oklch(79.0% 0.0000 0.0)", "80": "oklch(80.0% 0.0000 0.0)", "81": "oklch(81.0% 0.0000 0.0)", "82": "oklch(82.0% 0.0000 0.0)", "83": "oklch(83.0% 0.0000 0.0)", "84": "oklch(84.0% 0.0000 0.0)", "85": "oklch(85.0% 0.0000 0.0)", "86": "oklch(86.0% 0.0000 0.0)", "87": "oklch(87.0% 0.0000 0.0)", "88": "oklch(88.0% 0.0000 0.0)", "89": "oklch(89.0% 0.0000 0.0)", "90": "oklch(90.0% 0.0000 0.0)", "91": "oklch(91.0% 0.0000 0.0)", "92": "oklch(92.0% 0.0000 0.0)", "93": "oklch(93.0% 0.0000 0.0)", "94": "oklch(94.0% 0.0000 0.0)", "95": "oklch(95.0% 0.0000 0.0)", "96": "oklch(96.0% 0.0000 0.0)", "97": "oklch(97.0% 0.0000 0.0)", "98": "oklch(98.0% 0.0000 0.0)"}, "badlands": {"10": "oklch(10.0% 0.0110 29.0)", "11": "oklch(11.0% 0.0110 29.0)", "12": "oklch(12.0% 0.0110 29.0)", "13": "oklch(13.0% 0.0110 29.0)", "14": "oklch(14.0% 0.0110 29.0)", "15": "oklch(15.0% 0.0110 29.0)", "16": "oklch(16.0% 0.0110 29.0)", "17": "oklch(17.0% 0.0110 29.0)", "18": "oklch(18.0% 0.0110 29.0)", "19": "oklch(19.0% 0.0110 29.0)", "20": "oklch(20.0% 0.0110 29.0)", "21": "oklch(21.0% 0.0110 29.0)", "22": "oklch(22.0% 0.0110 29.0)", "23": "oklch(23.0% 0.0110 29.0)", "24": "oklch(24.0% 0.0110 29.0)", "25": "oklch(25.0% 0.0110 29.0)", "26": "oklch(26.0% 0.0110 29.0)", "27": "oklch(27.0% 0.0110 29.0)", "28": "oklch(28.0% 0.0110 29.0)", "29": "oklch(29.0% 0.0110 29.0)", "30": "oklch(30.0% 0.0110 29.0)", "31": "oklch(31.0% 0.0110 29.0)", "32": "oklch(32.0% 0.0110 29.0)", "33": "oklch(33.0% 0.0110 29.0)", "34": "oklch(34.0% 0.0110 29.0)", "35": "oklch(35.0% 0.0110 29.0)", "36": "oklch(36.0% 0.0110 29.0)", "37": "oklch(37.0% 0.0110 29.0)", "38": "oklch(38.0% 0.0110 29.0)", "39": "oklch(39.0% 0.0110 29.0)", "40": "oklch(40.0% 0.0110 29.0)", "41": "oklch(41.0% 0.0110 29.0)", "42": "oklch(42.0% 0.0110 29.0)", "43": "oklch(43.0% 0.0110 29.0)", "44": "oklch(44.0% 0.0110 29.0)", "45": "oklch(45.0% 0.0110 29.0)", "46": "oklch(46.0% 0.0110 29.0)", "47": "oklch(47.0% 0.0110 29.0)", "48": "oklch(48.0% 0.0110 29.0)", "49": "oklch(49.0% 0.0110 29.0)", "50": "oklch(50.0% 0.0110 29.0)", "51": "oklch(51.0% 0.0110 29.0)", "52": "oklch(52.0% 0.0110 29.0)", "53": "oklch(53.0% 0.0110 29.0)", "54": "oklch(54.0% 0.0110 29.0)", "55": "oklch(55.0% 0.0110 29.0)", "56": "oklch(56.0% 0.0110 29.0)", "57": "oklch(57.0% 0.0110 29.0)", "58": "oklch(58.0% 0.0110 29.0)", "59": "oklch(59.0% 0.0110 29.0)", "60": "oklch(60.0% 0.0110 29.0)", "61": "oklch(61.0% 0.0110 29.0)", "62": "oklch(62.0% 0.0110 29.0)", "63": "oklch(63.0% 0.0110 29.0)", "64": "oklch(64.0% 0.0110 29.0)", "65": "oklch(65.0% 0.0110 29.0)", "66": "oklch(66.0% 0.0110 29.0)", "67": "oklch(67.0% 0.0110 29.0)", "68": "oklch(68.0% 0.0110 29.0)", "69": "oklch(69.0% 0.0110 29.0)", "70": "oklch(70.0% 0.0110 29.0)", "71": "oklch(71.0% 0.0110 29.0)", "72": "oklch(72.0% 0.0110 29.0)", "73": "oklch(73.0% 0.0110 29.0)", "74": "oklch(74.0% 0.0110 29.0)", "75": "oklch(75.0% 0.0110 29.0)", "76": "oklch(76.0% 0.0110 29.0)", "77": "oklch(77.0% 0.0110 29.0)", "78": "oklch(78.0% 0.0110 29.0)", "79": "oklch(79.0% 0.0110 29.0)", "80": "oklch(80.0% 0.0110 29.0)", "81": "oklch(81.0% 0.0110 29.0)", "82": "oklch(82.0% 0.0110 29.0)", "83": "oklch(83.0% 0.0110 29.0)", "84": "oklch(84.0% 0.0110 29.0)", "85": "oklch(85.0% 0.0110 29.0)", "86": "oklch(86.0% 0.0110 29.0)", "87": "oklch(87.0% 0.0110 29.0)", "88": "oklch(88.0% 0.0110 29.0)", "89": "oklch(89.0% 0.0110 29.0)", "90": "oklch(90.0% 0.0110 29.0)", "91": "oklch(91.0% 0.0110 29.0)", "92": "oklch(92.0% 0.0110 29.0)", "93": "oklch(93.0% 0.0110 29.0)", "94": "oklch(94.0% 0.0110 29.0)", "95": "oklch(95.0% 0.0110 29.0)", "96": "oklch(96.0% 0.0110 29.0)", "97": "oklch(97.0% 0.0110 29.0)", "98": "oklch(98.0% 0.0097 29.0)"}, "chaparral": {"10": "oklch(10.0% 0.0110 62.5)", "11": "oklch(11.0% 0.0110 62.5)", "12": "oklch(12.0% 0.0110 62.5)", "13": "oklch(13.0% 0.0110 62.5)", "14": "oklch(14.0% 0.0110 62.5)", "15": "oklch(15.0% 0.0110 62.5)", "16": "oklch(16.0% 0.0110 62.5)", "17": "oklch(17.0% 0.0110 62.5)", "18": "oklch(18.0% 0.0110 62.5)", "19": "oklch(19.0% 0.0110 62.5)", "20": "oklch(20.0% 0.0110 62.5)", "21": "oklch(21.0% 0.0110 62.5)", "22": "oklch(22.0% 0.0110 62.5)", "23": "oklch(23.0% 0.0110 62.5)", "24": "oklch(24.0% 0.0110 62.5)", "25": "oklch(25.0% 0.0110 62.5)", "26": "oklch(26.0% 0.0110 62.5)", "27": "oklch(27.0% 0.0110 62.5)", "28": "oklch(28.0% 0.0110 62.5)", "29": "oklch(29.0% 0.0110 62.5)", "30": "oklch(30.0% 0.0110 62.5)", "31": "oklch(31.0% 0.0110 62.5)", "32": "oklch(32.0% 0.0110 62.5)", "33": "oklch(33.0% 0.0110 62.5)", "34": "oklch(34.0% 0.0110 62.5)", "35": "oklch(35.0% 0.0110 62.5)", "36": "oklch(36.0% 0.0110 62.5)", "37": "oklch(37.0% 0.0110 62.5)", "38": "oklch(38.0% 0.0110 62.5)", "39": "oklch(39.0% 0.0110 62.5)", "40": "oklch(40.0% 0.0110 62.5)", "41": "oklch(41.0% 0.0110 62.5)", "42": "oklch(42.0% 0.0110 62.5)", "43": "oklch(43.0% 0.0110 62.5)", "44": "oklch(44.0% 0.0110 62.5)", "45": "oklch(45.0% 0.0110 62.5)", "46": "oklch(46.0% 0.0110 62.5)", "47": "oklch(47.0% 0.0110 62.5)", "48": "oklch(48.0% 0.0110 62.5)", "49": "oklch(49.0% 0.0110 62.5)", "50": "oklch(50.0% 0.0110 62.5)", "51": "oklch(51.0% 0.0110 62.5)", "52": "oklch(52.0% 0.0110 62.5)", "53": "oklch(53.0% 0.0110 62.5)", "54": "oklch(54.0% 0.0110 62.5)", "55": "oklch(55.0% 0.0110 62.5)", "56": "oklch(56.0% 0.0110 62.5)", "57": "oklch(57.0% 0.0110 62.5)", "58": "oklch(58.0% 0.0110 62.5)", "59": "oklch(59.0% 0.0110 62.5)", "60": "oklch(60.0% 0.0110 62.5)", "61": "oklch(61.0% 0.0110 62.5)", "62": "oklch(62.0% 0.0110 62.5)", "63": "oklch(63.0% 0.0110 62.5)", "64": "oklch(64.0% 0.0110 62.5)", "65": "oklch(65.0% 0.0110 62.5)", "66": "oklch(66.0% 0.0110 62.5)", "67": "oklch(67.0% 0.0110 62.5)", "68": "oklch(68.0% 0.0110 62.5)", "69": "oklch(69.0% 0.0110 62.5)", "70": "oklch(70.0% 0.0110 62.5)", "71": "oklch(71.0% 0.0110 62.5)", "72": "oklch(72.0% 0.0110 62.5)", "73": "oklch(73.0% 0.0110 62.5)", "74": "oklch(74.0% 0.0110 62.5)", "75": "oklch(75.0% 0.0110 62.5)", "76": "oklch(76.0% 0.0110 62.5)", "77": "oklch(77.0% 0.0110 62.5)", "78": "oklch(78.0% 0.0110 62.5)", "79": "oklch(79.0% 0.0110 62.5)", "80": "oklch(80.0% 0.0110 62.5)", "81": "oklch(81.0% 0.0110 62.5)", "82": "oklch(82.0% 0.0110 62.5)", "83": "oklch(83.0% 0.0110 62.5)", "84": "oklch(84.0% 0.0110 62.5)", "85": "oklch(85.0% 0.0110 62.5)", "86": "oklch(86.0% 0.0110 62.5)", "87": "oklch(87.0% 0.0110 62.5)", "88": "oklch(88.0% 0.0110 62.5)", "89": "oklch(89.0% 0.0110 62.5)", "90": "oklch(90.0% 0.0110 62.5)", "91": "oklch(91.0% 0.0110 62.5)", "92": "oklch(92.0% 0.0110 62.5)", "93": "oklch(93.0% 0.0110 62.5)", "94": "oklch(94.0% 0.0110 62.5)", "95": "oklch(95.0% 0.0110 62.5)", "96": "oklch(96.0% 0.0110 62.5)", "97": "oklch(97.0% 0.0110 62.5)", "98": "oklch(98.0% 0.0110 62.5)"}, "savanna": {"10": "oklch(10.0% 0.0110 104.0)", "11": "oklch(11.0% 0.0110 104.0)", "12": "oklch(12.0% 0.0110 104.0)", "13": "oklch(13.0% 0.0110 104.0)", "14": "oklch(14.0% 0.0110 104.0)", "15": "oklch(15.0% 0.0110 104.0)", "16": "oklch(16.0% 0.0110 104.0)", "17": "oklch(17.0% 0.0110 104.0)", "18": "oklch(18.0% 0.0110 104.0)", "19": "oklch(19.0% 0.0110 104.0)", "20": "oklch(20.0% 0.0110 104.0)", "21": "oklch(21.0% 0.0110 104.0)", "22": "oklch(22.0% 0.0110 104.0)", "23": "oklch(23.0% 0.0110 104.0)", "24": "oklch(24.0% 0.0110 104.0)", "25": "oklch(25.0% 0.0110 104.0)", "26": "oklch(26.0% 0.0110 104.0)", "27": "oklch(27.0% 0.0110 104.0)", "28": "oklch(28.0% 0.0110 104.0)", "29": "oklch(29.0% 0.0110 104.0)", "30": "oklch(30.0% 0.0110 104.0)", "31": "oklch(31.0% 0.0110 104.0)", "32": "oklch(32.0% 0.0110 104.0)", "33": "oklch(33.0% 0.0110 104.0)", "34": "oklch(34.0% 0.0110 104.0)", "35": "oklch(35.0% 0.0110 104.0)", "36": "oklch(36.0% 0.0110 104.0)", "37": "oklch(37.0% 0.0110 104.0)", "38": "oklch(38.0% 0.0110 104.0)", "39": "oklch(39.0% 0.0110 104.0)", "40": "oklch(40.0% 0.0110 104.0)", "41": "oklch(41.0% 0.0110 104.0)", "42": "oklch(42.0% 0.0110 104.0)", "43": "oklch(43.0% 0.0110 104.0)", "44": "oklch(44.0% 0.0110 104.0)", "45": "oklch(45.0% 0.0110 104.0)", "46": "oklch(46.0% 0.0110 104.0)", "47": "oklch(47.0% 0.0110 104.0)", "48": "oklch(48.0% 0.0110 104.0)", "49": "oklch(49.0% 0.0110 104.0)", "50": "oklch(50.0% 0.0110 104.0)", "51": "oklch(51.0% 0.0110 104.0)", "52": "oklch(52.0% 0.0110 104.0)", "53": "oklch(53.0% 0.0110 104.0)", "54": "oklch(54.0% 0.0110 104.0)", "55": "oklch(55.0% 0.0110 104.0)", "56": "oklch(56.0% 0.0110 104.0)", "57": "oklch(57.0% 0.0110 104.0)", "58": "oklch(58.0% 0.0110 104.0)", "59": "oklch(59.0% 0.0110 104.0)", "60": "oklch(60.0% 0.0110 104.0)", "61": "oklch(61.0% 0.0110 104.0)", "62": "oklch(62.0% 0.0110 104.0)", "63": "oklch(63.0% 0.0110 104.0)", "64": "oklch(64.0% 0.0110 104.0)", "65": "oklch(65.0% 0.0110 104.0)", "66": "oklch(66.0% 0.0110 104.0)", "67": "oklch(67.0% 0.0110 104.0)", "68": "oklch(68.0% 0.0110 104.0)", "69": "oklch(69.0% 0.0110 104.0)", "70": "oklch(70.0% 0.0110 104.0)", "71": "oklch(71.0% 0.0110 104.0)", "72": "oklch(72.0% 0.0110 104.0)", "73": "oklch(73.0% 0.0110 104.0)", "74": "oklch(74.0% 0.0110 104.0)", "75": "oklch(75.0% 0.0110 104.0)", "76": "oklch(76.0% 0.0110 104.0)", "77": "oklch(77.0% 0.0110 104.0)", "78": "oklch(78.0% 0.0110 104.0)", "79": "oklch(79.0% 0.0110 104.0)", "80": "oklch(80.0% 0.0110 104.0)", "81": "oklch(81.0% 0.0110 104.0)", "82": "oklch(82.0% 0.0110 104.0)", "83": "oklch(83.0% 0.0110 104.0)", "84": "oklch(84.0% 0.0110 104.0)", "85": "oklch(85.0% 0.0110 104.0)", "86": "oklch(86.0% 0.0110 104.0)", "87": "oklch(87.0% 0.0110 104.0)", "88": "oklch(88.0% 0.0110 104.0)", "89": "oklch(89.0% 0.0110 104.0)", "90": "oklch(90.0% 0.0110 104.0)", "91": "oklch(91.0% 0.0110 104.0)", "92": "oklch(92.0% 0.0110 104.0)", "93": "oklch(93.0% 0.0110 104.0)", "94": "oklch(94.0% 0.0110 104.0)", "95": "oklch(95.0% 0.0110 104.0)", "96": "oklch(96.0% 0.0110 104.0)", "97": "oklch(97.0% 0.0110 104.0)", "98": "oklch(98.0% 0.0110 104.0)"}, "grassland": {"10": "oklch(10.0% 0.0110 148.0)", "11": "oklch(11.0% 0.0110 148.0)", "12": "oklch(12.0% 0.0110 148.0)", "13": "oklch(13.0% 0.0110 148.0)", "14": "oklch(14.0% 0.0110 148.0)", "15": "oklch(15.0% 0.0110 148.0)", "16": "oklch(16.0% 0.0110 148.0)", "17": "oklch(17.0% 0.0110 148.0)", "18": "oklch(18.0% 0.0110 148.0)", "19": "oklch(19.0% 0.0110 148.0)", "20": "oklch(20.0% 0.0110 148.0)", "21": "oklch(21.0% 0.0110 148.0)", "22": "oklch(22.0% 0.0110 148.0)", "23": "oklch(23.0% 0.0110 148.0)", "24": "oklch(24.0% 0.0110 148.0)", "25": "oklch(25.0% 0.0110 148.0)", "26": "oklch(26.0% 0.0110 148.0)", "27": "oklch(27.0% 0.0110 148.0)", "28": "oklch(28.0% 0.0110 148.0)", "29": "oklch(29.0% 0.0110 148.0)", "30": "oklch(30.0% 0.0110 148.0)", "31": "oklch(31.0% 0.0110 148.0)", "32": "oklch(32.0% 0.0110 148.0)", "33": "oklch(33.0% 0.0110 148.0)", "34": "oklch(34.0% 0.0110 148.0)", "35": "oklch(35.0% 0.0110 148.0)", "36": "oklch(36.0% 0.0110 148.0)", "37": "oklch(37.0% 0.0110 148.0)", "38": "oklch(38.0% 0.0110 148.0)", "39": "oklch(39.0% 0.0110 148.0)", "40": "oklch(40.0% 0.0110 148.0)", "41": "oklch(41.0% 0.0110 148.0)", "42": "oklch(42.0% 0.0110 148.0)", "43": "oklch(43.0% 0.0110 148.0)", "44": "oklch(44.0% 0.0110 148.0)", "45": "oklch(45.0% 0.0110 148.0)", "46": "oklch(46.0% 0.0110 148.0)", "47": "oklch(47.0% 0.0110 148.0)", "48": "oklch(48.0% 0.0110 148.0)", "49": "oklch(49.0% 0.0110 148.0)", "50": "oklch(50.0% 0.0110 148.0)", "51": "oklch(51.0% 0.0110 148.0)", "52": "oklch(52.0% 0.0110 148.0)", "53": "oklch(53.0% 0.0110 148.0)", "54": "oklch(54.0% 0.0110 148.0)", "55": "oklch(55.0% 0.0110 148.0)", "56": "oklch(56.0% 0.0110 148.0)", "57": "oklch(57.0% 0.0110 148.0)", "58": "oklch(58.0% 0.0110 148.0)", "59": "oklch(59.0% 0.0110 148.0)", "60": "oklch(60.0% 0.0110 148.0)", "61": "oklch(61.0% 0.0110 148.0)", "62": "oklch(62.0% 0.0110 148.0)", "63": "oklch(63.0% 0.0110 148.0)", "64": "oklch(64.0% 0.0110 148.0)", "65": "oklch(65.0% 0.0110 148.0)", "66": "oklch(66.0% 0.0110 148.0)", "67": "oklch(67.0% 0.0110 148.0)", "68": "oklch(68.0% 0.0110 148.0)", "69": "oklch(69.0% 0.0110 148.0)", "70": "oklch(70.0% 0.0110 148.0)", "71": "oklch(71.0% 0.0110 148.0)", "72": "oklch(72.0% 0.0110 148.0)", "73": "oklch(73.0% 0.0110 148.0)", "74": "oklch(74.0% 0.0110 148.0)", "75": "oklch(75.0% 0.0110 148.0)", "76": "oklch(76.0% 0.0110 148.0)", "77": "oklch(77.0% 0.0110 148.0)", "78": "oklch(78.0% 0.0110 148.0)", "79": "oklch(79.0% 0.0110 148.0)", "80": "oklch(80.0% 0.0110 148.0)", "81": "oklch(81.0% 0.0110 148.0)", "82": "oklch(82.0% 0.0110 148.0)", "83": "oklch(83.0% 0.0110 148.0)", "84": "oklch(84.0% 0.0110 148.0)", "85": "oklch(85.0% 0.0110 148.0)", "86": "oklch(86.0% 0.0110 148.0)", "87": "oklch(87.0% 0.0110 148.0)", "88": "oklch(88.0% 0.0110 148.0)", "89": "oklch(89.0% 0.0110 148.0)", "90": "oklch(90.0% 0.0110 148.0)", "91": "oklch(91.0% 0.0110 148.0)", "92": "oklch(92.0% 0.0110 148.0)", "93": "oklch(93.0% 0.0110 148.0)", "94": "oklch(94.0% 0.0110 148.0)", "95": "oklch(95.0% 0.0110 148.0)", "96": "oklch(96.0% 0.0110 148.0)", "97": "oklch(97.0% 0.0110 148.0)", "98": "oklch(98.0% 0.0110 148.0)"}, "tundra": {"10": "oklch(10.0% 0.0110 262.0)", "11": "oklch(11.0% 0.0110 262.0)", "12": "oklch(12.0% 0.0110 262.0)", "13": "oklch(13.0% 0.0110 262.0)", "14": "oklch(14.0% 0.0110 262.0)", "15": "oklch(15.0% 0.0110 262.0)", "16": "oklch(16.0% 0.0110 262.0)", "17": "oklch(17.0% 0.0110 262.0)", "18": "oklch(18.0% 0.0110 262.0)", "19": "oklch(19.0% 0.0110 262.0)", "20": "oklch(20.0% 0.0110 262.0)", "21": "oklch(21.0% 0.0110 262.0)", "22": "oklch(22.0% 0.0110 262.0)", "23": "oklch(23.0% 0.0110 262.0)", "24": "oklch(24.0% 0.0110 262.0)", "25": "oklch(25.0% 0.0110 262.0)", "26": "oklch(26.0% 0.0110 262.0)", "27": "oklch(27.0% 0.0110 262.0)", "28": "oklch(28.0% 0.0110 262.0)", "29": "oklch(29.0% 0.0110 262.0)", "30": "oklch(30.0% 0.0110 262.0)", "31": "oklch(31.0% 0.0110 262.0)", "32": "oklch(32.0% 0.0110 262.0)", "33": "oklch(33.0% 0.0110 262.0)", "34": "oklch(34.0% 0.0110 262.0)", "35": "oklch(35.0% 0.0110 262.0)", "36": "oklch(36.0% 0.0110 262.0)", "37": "oklch(37.0% 0.0110 262.0)", "38": "oklch(38.0% 0.0110 262.0)", "39": "oklch(39.0% 0.0110 262.0)", "40": "oklch(40.0% 0.0110 262.0)", "41": "oklch(41.0% 0.0110 262.0)", "42": "oklch(42.0% 0.0110 262.0)", "43": "oklch(43.0% 0.0110 262.0)", "44": "oklch(44.0% 0.0110 262.0)", "45": "oklch(45.0% 0.0110 262.0)", "46": "oklch(46.0% 0.0110 262.0)", "47": "oklch(47.0% 0.0110 262.0)", "48": "oklch(48.0% 0.0110 262.0)", "49": "oklch(49.0% 0.0110 262.0)", "50": "oklch(50.0% 0.0110 262.0)", "51": "oklch(51.0% 0.0110 262.0)", "52": "oklch(52.0% 0.0110 262.0)", "53": "oklch(53.0% 0.0110 262.0)", "54": "oklch(54.0% 0.0110 262.0)", "55": "oklch(55.0% 0.0110 262.0)", "56": "oklch(56.0% 0.0110 262.0)", "57": "oklch(57.0% 0.0110 262.0)", "58": "oklch(58.0% 0.0110 262.0)", "59": "oklch(59.0% 0.0110 262.0)", "60": "oklch(60.0% 0.0110 262.0)", "61": "oklch(61.0% 0.0110 262.0)", "62": "oklch(62.0% 0.0110 262.0)", "63": "oklch(63.0% 0.0110 262.0)", "64": "oklch(64.0% 0.0110 262.0)", "65": "oklch(65.0% 0.0110 262.0)", "66": "oklch(66.0% 0.0110 262.0)", "67": "oklch(67.0% 0.0110 262.0)", "68": "oklch(68.0% 0.0110 262.0)", "69": "oklch(69.0% 0.0110 262.0)", "70": "oklch(70.0% 0.0110 262.0)", "71": "oklch(71.0% 0.0110 262.0)", "72": "oklch(72.0% 0.0110 262.0)", "73": "oklch(73.0% 0.0110 262.0)", "74": "oklch(74.0% 0.0110 262.0)", "75": "oklch(75.0% 0.0110 262.0)", "76": "oklch(76.0% 0.0110 262.0)", "77": "oklch(77.0% 0.0110 262.0)", "78": "oklch(78.0% 0.0110 262.0)", "79": "oklch(79.0% 0.0110 262.0)", "80": "oklch(80.0% 0.0110 262.0)", "81": "oklch(81.0% 0.0110 262.0)", "82": "oklch(82.0% 0.0110 262.0)", "83": "oklch(83.0% 0.0110 262.0)", "84": "oklch(84.0% 0.0110 262.0)", "85": "oklch(85.0% 0.0110 262.0)", "86": "oklch(86.0% 0.0110 262.0)", "87": "oklch(87.0% 0.0110 262.0)", "88": "oklch(88.0% 0.0110 262.0)", "89": "oklch(89.0% 0.0110 262.0)", "90": "oklch(90.0% 0.0110 262.0)", "91": "oklch(91.0% 0.0110 262.0)", "92": "oklch(92.0% 0.0110 262.0)", "93": "oklch(93.0% 0.0110 262.0)", "94": "oklch(94.0% 0.0110 262.0)", "95": "oklch(95.0% 0.0110 262.0)", "96": "oklch(96.0% 0.0110 262.0)", "97": "oklch(97.0% 0.0110 262.0)", "98": "oklch(98.0% 0.0094 262.0)"}, "red": {"10": "oklch(10.0% 0.0391 29.0)", "11": "oklch(11.0% 0.0429 29.0)", "12": "oklch(12.0% 0.0468 29.0)", "13": "oklch(13.0% 0.0506 29.0)", "14": "oklch(14.0% 0.0545 29.0)", "15": "oklch(15.0% 0.0583 29.0)", "16": "oklch(16.0% 0.0621 29.0)", "17": "oklch(17.0% 0.0659 29.0)", "18": "oklch(18.0% 0.0697 29.0)", "19": "oklch(19.0% 0.0735 29.0)", "20": "oklch(20.0% 0.0773 29.0)", "21": "oklch(21.0% 0.0810 29.0)", "22": "oklch(22.0% 0.0847 29.0)", "23": "oklch(23.0% 0.0885 29.0)", "24": "oklch(24.0% 0.0922 29.0)", "25": "oklch(25.0% 0.0958 29.0)", "26": "oklch(26.0% 0.0995 29.0)", "27": "oklch(27.0% 0.1031 29.0)", "28": "oklch(28.0% 0.1067 29.0)", "29": "oklch(29.0% 0.1103 29.0)", "30": "oklch(30.0% 0.1139 29.0)", "31": "oklch(31.0% 0.1174 29.0)", "32": "oklch(32.0% 0.1209 29.0)", "33": "oklch(33.0% 0.1244 29.0)", "34": "oklch(34.0% 0.1278 29.0)", "35": "oklch(35.0% 0.1312 29.0)", "36": "oklch(36.0% 0.1346 29.0)", "37": "oklch(37.0% 0.1378 29.0)", "38": "oklch(38.0% 0.1411 29.0)", "39": "oklch(39.0% 0.1443 29.0)", "40": "oklch(40.0% 0.1474 29.0)", "41": "oklch(41.0% 0.1505 29.0)", "42": "oklch(42.0% 0.1535 29.0)", "43": "oklch(43.0% 0.1564 29.0)", "44": "oklch(44.0% 0.1592 29.0)", "45": "oklch(45.0% 0.1619 29.0)", "46": "oklch(46.0% 0.1645 29.0)", "47": "oklch(47.0% 0.1670 29.0)", "48": "oklch(48.0% 0.1694 29.0)", "49": "oklch(49.0% 0.1716 29.0)", "50": "oklch(50.0% 0.1737 29.0)", "51": "oklch(51.0% 0.1756 29.0)", "52": "oklch(52.0% 0.1774 29.0)", "53": "oklch(53.0% 0.1789 29.0)", "54": "oklch(54.0% 0.1802 29.0)", "55": "oklch(55.0% 0.1813 29.0)", "56": "oklch(56.0% 0.1821 29.0)", "57": "oklch(57.0% 0.1827 29.0)", "58": "oklch(58.0% 0.1829 29.0)", "59": "oklch(59.0% 0.1829 29.0)", "60": "oklch(60.0% 0.1825 29.0)", "61": "oklch(61.0% 0.1819 29.0)", "62": "oklch(62.0% 0.1809 29.0)", "63": "oklch(63.0% 0.1795 29.0)", "64": "oklch(64.0% 0.1778 29.0)", "65": "oklch(65.0% 0.1758 29.0)", "66": "oklch(66.0% 0.1735 29.0)", "67": "oklch(67.0% 0.1709 29.0)", "68": "oklch(68.0% 0.1680 29.0)", "69": "oklch(69.0% 0.1648 29.0)", "70": "oklch(70.0% 0.1613 29.0)", "71": "oklch(71.0% 0.1576 29.0)", "72": "oklch(72.0% 0.1537 29.0)", "73": "oklch(73.0% 0.1496 29.0)", "74": "oklch(74.0% 0.1453 29.0)", "75": "oklch(75.0% 0.1408 29.0)", "76": "oklch(76.0% 0.1361 29.0)", "77": "oklch(77.0% 0.1313 29.0)", "78": "oklch(78.0% 0.1264 29.0)", "79": "oklch(79.0% 0.1213 29.0)", "80": "oklch(80.0% 0.1147 29.0)", "81": "oklch(81.0% 0.1079 29.0)", "82": "oklch(82.0% 0.1012 29.0)", "83": "oklch(83.0% 0.0947 29.0)", "84": "oklch(84.0% 0.0883 29.0)", "85": "oklch(85.0% 0.0820 29.0)", "86": "oklch(86.0% 0.0758 29.0)", "87": "oklch(87.0% 0.0697 29.0)", "88": "oklch(88.0% 0.0638 29.0)", "89": "oklch(89.0% 0.0579 29.0)", "90": "oklch(90.0% 0.0522 29.0)", "91": "oklch(91.0% 0.0466 29.0)", "92": "oklch(92.0% 0.0410 29.0)", "93": "oklch(93.0% 0.0356 29.0)", "94": "oklch(94.0% 0.0302 29.0)", "95": "oklch(95.0% 0.0250 29.0)", "96": "oklch(96.0% 0.0198 29.0)", "97": "oklch(97.0% 0.0147 29.0)", "98": "oklch(98.0% 0.0097 29.0)"}, "orange": {"10": "oklch(10.0% 0.0213 62.5)", "11": "oklch(11.0% 0.0234 62.5)", "12": "oklch(12.0% 0.0256 62.5)", "13": "oklch(13.0% 0.0277 62.5)", "14": "oklch(14.0% 0.0298 62.5)", "15": "oklch(15.0% 0.0319 62.5)", "16": "oklch(16.0% 0.0340 62.5)", "17": "oklch(17.0% 0.0361 62.5)", "18": "oklch(18.0% 0.0382 62.5)", "19": "oklch(19.0% 0.0403 62.5)", "20": "oklch(20.0% 0.0424 62.5)", "21": "oklch(21.0% 0.0445 62.5)", "22": "oklch(22.0% 0.0465 62.5)", "23": "oklch(23.0% 0.0486 62.5)", "24": "oklch(24.0% 0.0507 62.5)", "25": "oklch(25.0% 0.0527 62.5)", "26": "oklch(26.0% 0.0548 62.5)", "27": "oklch(27.0% 0.0569 62.5)", "28": "oklch(28.0% 0.0589 62.5)", "29": "oklch(29.0% 0.0609 62.5)", "30": "oklch(30.0% 0.0630 62.5)", "31": "oklch(31.0% 0.0650 62.5)", "32": "oklch(32.0% 0.0670 62.5)", "33": "oklch(33.0% 0.0690 62.5)", "34": "oklch(34.0% 0.0710 62.5)", "35": "oklch(35.0% 0.0730 62.5)", "36": "oklch(36.0% 0.0749 62.5)", "37": "oklch(37.0% 0.0769 62.5)", "38": "oklch(38.0% 0.0788 62.5)", "39": "oklch(39.0% 0.0808 62.5)", "40": "oklch(40.0% 0.0827 62.5)", "41": "oklch(41.0% 0.0846 62.5)", "42": "oklch(42.0% 0.0864 62.5)", "43": "oklch(43.0% 0.0883 62.5)", "44": "oklch(44.0% 0.0901 62.5)", "45": "oklch(45.0% 0.0919 62.5)", "46": "oklch(46.0% 0.0937 62.5)", "47": "oklch(47.0% 0.0954 62.5)", "48": "oklch(48.0% 0.0971 62.5)", "49": "oklch(49.0% 0.0987 62.5)", "50": "oklch(50.0% 0.1004 62.5)", "51": "oklch(51.0% 0.1019 62.5)", "52": "oklch(52.0% 0.1034 62.5)", "53": "oklch(53.0% 0.1049 62.5)", "54": "oklch(54.0% 0.1062 62.5)", "55": "oklch(55.0% 0.1075 62.5)", "56": "oklch(56.0% 0.1087 62.5)", "57": "oklch(57.0% 0.1098 62.5)", "58": "oklch(58.0% 0.1108 62.5)", "59": "oklch(59.0% 0.1117 62.5)", "60": "oklch(60.0% 0.1124 62.5)", "61": "oklch(61.0% 0.1130 62.5)", "62": "oklch(62.0% 0.1134 62.5)", "63": "oklch(63.0% 0.1136 62.5)", "64": "oklch(64.0% 0.1136 62.5)", "65": "oklch(65.0% 0.1133 62.5)", "66": "oklch(66.0% 0.1129 62.5)", "67": "oklch(67.0% 0.1121 62.5)", "68": "oklch(68.0% 0.1111 62.5)", "69": "oklch(69.0% 0.1099 62.5)", "70": "oklch(70.0% 0.1083 62.5)", "71": "oklch(71.0% 0.1066 62.5)", "72": "oklch(72.0% 0.1045 62.5)", "73": "oklch(73.0% 0.1023 62.5)", "74": "oklch(74.0% 0.0998 62.5)", "75": "oklch(75.0% 0.0971 62.5)", "76": "oklch(76.0% 0.0942 62.5)", "77": "oklch(77.0% 0.0912 62.5)", "78": "oklch(78.0% 0.0880 62.5)", "79": "oklch(79.0% 0.0847 62.5)", "80": "oklch(80.0% 0.0812 62.5)", "81": "oklch(81.0% 0.0777 62.5)", "82": "oklch(82.0% 0.0740 62.5)", "83": "oklch(83.0% 0.0703 62.5)", "84": "oklch(84.0% 0.0665 62.5)", "85": "oklch(85.0% 0.0627 62.5)", "86": "oklch(86.0% 0.0587 62.5)", "87": "oklch(87.0% 0.0547 62.5)", "88": "oklch(88.0% 0.0507 62.5)", "89": "oklch(89.0% 0.0466 62.5)", "90": "oklch(90.0% 0.0425 62.5)", "91": "oklch(91.0% 0.0384 62.5)", "92": "oklch(92.0% 0.0342 62.5)", "93": "oklch(93.0% 0.0300 62.5)", "94": "oklch(94.0% 0.0258 62.5)", "95": "oklch(95.0% 0.0215 62.5)", "96": "oklch(96.0% 0.0173 62.5)", "97": "oklch(97.0% 0.0130 62.5)", "98": "oklch(98.0% 0.0087 62.5)"}, "yellow": {"10": "oklch(10.0% 0.0114 104.0)", "11": "oklch(11.0% 0.0125 104.0)", "12": "oklch(12.0% 0.0136 104.0)", "13": "oklch(13.0% 0.0147 104.0)", "14": "oklch(14.0% 0.0159 104.0)", "15": "oklch(15.0% 0.0170 104.0)", "16": "oklch(16.0% 0.0181 104.0)", "17": "oklch(17.0% 0.0192 104.0)", "18": "oklch(18.0% 0.0203 104.0)", "19": "oklch(19.0% 0.0215 104.0)", "20": "oklch(20.0% 0.0226 104.0)", "21": "oklch(21.0% 0.0237 104.0)", "22": "oklch(22.0% 0.0248 104.0)", "23": "oklch(23.0% 0.0259 104.0)", "24": "oklch(24.0% 0.0270 104.0)", "25": "oklch(25.0% 0.0281 104.0)", "26": "oklch(26.0% 0.0292 104.0)", "27": "oklch(27.0% 0.0303 104.0)", "28": "oklch(28.0% 0.0314 104.0)", "29": "oklch(29.0% 0.0325 104.0)", "30": "oklch(30.0% 0.0336 104.0)", "31": "oklch(31.0% 0.0347 104.0)", "32": "oklch(32.0% 0.0358 104.0)", "33": "oklch(33.0% 0.0369 104.0)", "34": "oklch(34.0% 0.0379 104.0)", "35": "oklch(35.0% 0.0390 104.0)", "36": "oklch(36.0% 0.0401 104.0)", "37": "oklch(37.0% 0.0411 104.0)", "38": "oklch(38.0% 0.0422 104.0)", "39": "oklch(39.0% 0.0433 104.0)", "40": "oklch(40.0% 0.0443 104.0)", "41": "oklch(41.0% 0.0453 104.0)", "42": "oklch(42.0% 0.0464 104.0)", "43": "oklch(43.0% 0.0474 104.0)", "44": "oklch(44.0% 0.0484 104.0)", "45": "oklch(45.0% 0.0494 104.0)", "46": "oklch(46.0% 0.0504 104.0)", "47": "oklch(47.0% 0.0514 104.0)", "48": "oklch(48.0% 0.0523 104.0)", "49": "oklch(49.0% 0.0533 104.0)", "50": "oklch(50.0% 0.0542 104.0)", "51": "oklch(51.0% 0.0552 104.0)", "52": "oklch(52.0% 0.0561 104.0)", "53": "oklch(53.0% 0.0569 104.0)", "54": "oklch(54.0% 0.0578 104.0)", "55": "oklch(55.0% 0.0586 104.0)", "56": "oklch(56.0% 0.0594 104.0)", "57": "oklch(57.0% 0.0602 104.0)", "58": "oklch(58.0% 0.0610 104.0)", "59": "oklch(59.0% 0.0616 104.0)", "60": "oklch(60.0% 0.0623 104.0)", "61": "oklch(61.0% 0.0629 104.0)", "62": "oklch(62.0% 0.0634 104.0)", "63": "oklch(63.0% 0.0639 104.0)", "64": "oklch(64.0% 0.0643 104.0)", "65": "oklch(65.0% 0.0646 104.0)", "66": "oklch(66.0% 0.0648 104.0)", "67": "oklch(67.0% 0.0649 104.0)", "68": "oklch(68.0% 0.0649 104.0)", "69": "oklch(69.0% 0.0648 104.0)", "70": "oklch(70.0% 0.0645 104.0)", "71": "oklch(71.0% 0.0641 104.0)", "72": "oklch(72.0% 0.0634 104.0)", "73": "oklch(73.0% 0.0627 104.0)", "74": "oklch(74.0% 0.0617 104.0)", "75": "oklch(75.0% 0.0606 104.0)", "76": "oklch(76.0% 0.0593 104.0)", "77": "oklch(77.0% 0.0578 104.0)", "78": "oklch(78.0% 0.0562 104.0)", "79": "oklch(79.0% 0.0544 104.0)", "80": "oklch(80.0% 0.0525 104.0)", "81": "oklch(81.0% 0.0504 104.0)", "82": "oklch(82.0% 0.0483 104.0)", "83": "oklch(83.0% 0.0461 104.0)", "84": "oklch(84.0% 0.0437 104.0)", "85": "oklch(85.0% 0.0413 104.0)", "86": "oklch(86.0% 0.0388 104.0)", "87": "oklch(87.0% 0.0363 104.0)", "88": "oklch(88.0% 0.0337 104.0)", "89": "oklch(89.0% 0.0311 104.0)", "90": "oklch(90.0% 0.0284 104.0)", "91": "oklch(91.0% 0.0256 104.0)", "92": "oklch(92.0% 0.0229 104.0)", "93": "oklch(93.0% 0.0201 104.0)", "94": "oklch(94.0% 0.0173 104.0)", "95": "oklch(95.0% 0.0145 104.0)", "96": "oklch(96.0% 0.0116 104.0)", "97": "oklch(97.0% 0.0087 104.0)", "98": "oklch(98.0% 0.0058 104.0)"}, "green": {"10": "oklch(10.0% 0.0158 148.0)", "11": "oklch(11.0% 0.0174 148.0)", "12": "oklch(12.0% 0.0190 148.0)", "13": "oklch(13.0% 0.0206 148.0)", "14": "oklch(14.0% 0.0221 148.0)", "15": "oklch(15.0% 0.0237 148.0)", "16": "oklch(16.0% 0.0253 148.0)", "17": "oklch(17.0% 0.0268 148.0)", "18": "oklch(18.0% 0.0284 148.0)", "19": "oklch(19.0% 0.0299 148.0)", "20": "oklch(20.0% 0.0315 148.0)", "21": "oklch(21.0% 0.0330 148.0)", "22": "oklch(22.0% 0.0346 148.0)", "23": "oklch(23.0% 0.0361 148.0)", "24": "oklch(24.0% 0.0377 148.0)", "25": "oklch(25.0% 0.0392 148.0)", "26": "oklch(26.0% 0.0407 148.0)", "27": "oklch(27.0% 0.0423 148.0)", "28": "oklch(28.0% 0.0438 148.0)", "29": "oklch(29.0% 0.0453 148.0)", "30": "oklch(30.0% 0.0468 148.0)", "31": "oklch(31.0% 0.0483 148.0)", "32": "oklch(32.0% 0.0498 148.0)", "33": "oklch(33.0% 0.0513 148.0)", "34": "oklch(34.0% 0.0528 148.0)", "35": "oklch(35.0% 0.0543 148.0)", "36": "oklch(36.0% 0.0558 148.0)", "37": "oklch(37.0% 0.0572 148.0)", "38": "oklch(38.0% 0.0587 148.0)", "39": "oklch(39.0% 0.0601 148.0)", "40": "oklch(40.0% 0.0616 148.0)", "41": "oklch(41.0% 0.0630 148.0)", "42": "oklch(42.0% 0.0644 148.0)", "43": "oklch(43.0% 0.0658 148.0)", "44": "oklch(44.0% 0.0672 148.0)", "45": "oklch(45.0% 0.0685 148.0)", "46": "oklch(46.0% 0.0699 148.0)", "47": "oklch(47.0% 0.0712 148.0)", "48": "oklch(48.0% 0.0725 148.0)", "49": "oklch(49.0% 0.0738 148.0)", "50": "oklch(50.0% 0.0750 148.0)", "51": "oklch(51.0% 0.0762 148.0)", "52": "oklch(52.0% 0.0774 148.0)", "53": "oklch(53.0% 0.0786 148.0)", "54": "oklch(54.0% 0.0797 148.0)", "55": "oklch(55.0% 0.0807 148.0)", "56": "oklch(56.0% 0.0817 148.0)", "57": "oklch(57.0% 0.0827 148.0)", "58": "oklch(58.0% 0.0835 148.0)", "59": "oklch(59.0% 0.0843 148.0)", "60": "oklch(60.0% 0.0850 148.0)", "61": "oklch(61.0% 0.0857 148.0)", "62": "oklch(62.0% 0.0862 148.0)", "63": "oklch(63.0% 0.0865 148.0)", "64": "oklch(64.0% 0.0868 148.0)", "65": "oklch(65.0% 0.0869 148.0)", "66": "oklch(66.0% 0.0868 148.0)", "67": "oklch(67.0% 0.0865 148.0)", "68": "oklch(68.0% 0.0861 148.0)", "69": "oklch(69.0% 0.0854 148.0)", "70": "oklch(70.0% 0.0845 148.0)", "71": "oklch(71.0% 0.0835 148.0)", "72": "oklch(72.0% 0.0822 148.0)", "73": "oklch(73.0% 0.0807 148.0)", "74": "oklch(74.0% 0.0790 148.0)", "75": "oklch(75.0% 0.0771 148.0)", "76": "oklch(76.0% 0.0750 148.0)", "77": "oklch(77.0% 0.0728 148.0)", "78": "oklch(78.0% 0.0704 148.0)", "79": "oklch(79.0% 0.0679 148.0)", "80": "oklch(80.0% 0.0652 148.0)", "81": "oklch(81.0% 0.0625 148.0)", "82": "oklch(82.0% 0.0596 148.0)", "83": "oklch(83.0% 0.0567 148.0)", "84": "oklch(84.0% 0.0537 148.0)", "85": "oklch(85.0% 0.0506 148.0)", "86": "oklch(86.0% 0.0475 148.0)", "87": "oklch(87.0% 0.0443 148.0)", "88": "oklch(88.0% 0.0411 148.0)", "89": "oklch(89.0% 0.0378 148.0)", "90": "oklch(90.0% 0.0345 148.0)", "91": "oklch(91.0% 0.0312 148.0)", "92": "oklch(92.0% 0.0278 148.0)", "93": "oklch(93.0% 0.0244 148.0)", "94": "oklch(94.0% 0.0210 148.0)", "95": "oklch(95.0% 0.0175 148.0)", "96": "oklch(96.0% 0.0140 148.0)", "97": "oklch(97.0% 0.0106 148.0)", "98": "oklch(98.0% 0.0071 148.0)"}, "blue": {"10": "oklch(10.0% 0.0285 262.0)", "11": "oklch(11.0% 0.0313 262.0)", "12": "oklch(12.0% 0.0341 262.0)", "13": "oklch(13.0% 0.0370 262.0)", "14": "oklch(14.0% 0.0398 262.0)", "15": "oklch(15.0% 0.0426 262.0)", "16": "oklch(16.0% 0.0454 262.0)", "17": "oklch(17.0% 0.0482 262.0)", "18": "oklch(18.0% 0.0509 262.0)", "19": "oklch(19.0% 0.0537 262.0)", "20": "oklch(20.0% 0.0565 262.0)", "21": "oklch(21.0% 0.0592 262.0)", "22": "oklch(22.0% 0.0620 262.0)", "23": "oklch(23.0% 0.0647 262.0)", "24": "oklch(24.0% 0.0674 262.0)", "25": "oklch(25.0% 0.0701 262.0)", "26": "oklch(26.0% 0.0728 262.0)", "27": "oklch(27.0% 0.0755 262.0)", "28": "oklch(28.0% 0.0782 262.0)", "29": "oklch(29.0% 0.0809 262.0)", "30": "oklch(30.0% 0.0835 262.0)", "31": "oklch(31.0% 0.0861 262.0)", "32": "oklch(32.0% 0.0887 262.0)", "33": "oklch(33.0% 0.0913 262.0)", "34": "oklch(34.0% 0.0939 262.0)", "35": "oklch(35.0% 0.0964 262.0)", "36": "oklch(36.0% 0.0990 262.0)", "37": "oklch(37.0% 0.1015 262.0)", "38": "oklch(38.0% 0.1039 262.0)", "39": "oklch(39.0% 0.1064 262.0)", "40": "oklch(40.0% 0.1088 262.0)", "41": "oklch(41.0% 0.1111 262.0)", "42": "oklch(42.0% 0.1135 262.0)", "43": "oklch(43.0% 0.1157 262.0)", "44": "oklch(44.0% 0.1180 262.0)", "45": "oklch(45.0% 0.1202 262.0)", "46": "oklch(46.0% 0.1223 262.0)", "47": "oklch(47.0% 0.1244 262.0)", "48": "oklch(48.0% 0.1264 262.0)", "49": "oklch(49.0% 0.1283 262.0)", "50": "oklch(50.0% 0.1301 262.0)", "51": "oklch(51.0% 0.1319 262.0)", "52": "oklch(52.0% 0.1336 262.0)", "53": "oklch(53.0% 0.1351 262.0)", "54": "oklch(54.0% 0.1365 262.0)", "55": "oklch(55.0% 0.1378 262.0)", "56": "oklch(56.0% 0.1390 262.0)", "57": "oklch(57.0% 0.1400 262.0)", "58": "oklch(58.0% 0.1408 262.0)", "59": "oklch(59.0% 0.1414 262.0)", "60": "oklch(60.0% 0.1419 262.0)", "61": "oklch(61.0% 0.1421 262.0)", "62": "oklch(62.0% 0.1421 262.0)", "63": "oklch(63.0% 0.1418 262.0)", "64": "oklch(64.0% 0.1413 262.0)", "65": "oklch(65.0% 0.1405 262.0)", "66": "oklch(66.0% 0.1394 262.0)", "67": "oklch(67.0% 0.1381 262.0)", "68": "oklch(68.0% 0.1365 262.0)", "69": "oklch(69.0% 0.1346 262.0)", "70": "oklch(70.0% 0.1324 262.0)", "71": "oklch(71.0% 0.1300 262.0)", "72": "oklch(72.0% 0.1273 262.0)", "73": "oklch(73.0% 0.1244 262.0)", "74": "oklch(74.0% 0.1212 262.0)", "75": "oklch(75.0% 0.1179 262.0)", "76": "oklch(76.0% 0.1144 262.0)", "77": "oklch(77.0% 0.1107 262.0)", "78": "oklch(78.0% 0.1068 262.0)", "79": "oklch(79.0% 0.1028 262.0)", "80": "oklch(80.0% 0.0986 262.0)", "81": "oklch(81.0% 0.0943 262.0)", "82": "oklch(82.0% 0.0898 262.0)", "83": "oklch(83.0% 0.0845 262.0)", "84": "oklch(84.0% 0.0792 262.0)", "85": "oklch(85.0% 0.0739 262.0)", "86": "oklch(86.0% 0.0687 262.0)", "87": "oklch(87.0% 0.0636 262.0)", "88": "oklch(88.0% 0.0584 262.0)", "89": "oklch(89.0% 0.0534 262.0)", "90": "oklch(90.0% 0.0483 262.0)", "91": "oklch(91.0% 0.0433 262.0)", "92": "oklch(92.0% 0.0384 262.0)", "93": "oklch(93.0% 0.0334 262.0)", "94": "oklch(94.0% 0.0285 262.0)", "95": "oklch(95.0% 0.0237 262.0)", "96": "oklch(96.0% 0.0189 262.0)", "97": "oklch(97.0% 0.0141 262.0)", "98": "oklch(98.0% 0.0094 262.0)"}} \ No newline at end of file diff --git a/notebooks/palettes/monobiome-vQBRsn.toml b/notebooks/palettes/monobiome-vQBRsn.toml new file mode 100644 index 0000000..cf8d1d9 --- /dev/null +++ b/notebooks/palettes/monobiome-vQBRsn.toml @@ -0,0 +1,1000 @@ +[alpine] +l10 = "#030303" +l11 = "#040404" +l12 = "#060606" +l13 = "#070707" +l14 = "#090909" +l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" +l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" +l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" +l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" +l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" +l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" +l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" +l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" +l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" +l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" +l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" +l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" +l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" +l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" +l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" +l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" +l95 = "#eeeeee" +l96 = "#f2f2f2" +l97 = "#f5f5f5" +l98 = "#f8f8f8" + +[badlands] +l10 = "#060302" +l11 = "#070303" +l12 = "#090504" +l13 = "#0b0605" +l14 = "#0d0807" +l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" +l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" +l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" +l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" +l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" +l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" +l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" +l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" +l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" +l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" +l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" +l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" +l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" +l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" +l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" +l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" +l95 = "#f6ecea" +l96 = "#f9efee" +l97 = "#fcf3f1" +l98 = "#fff6f5" + +[chaparral] +l10 = "#050301" +l11 = "#070402" +l12 = "#080503" +l13 = "#0a0704" +l14 = "#0c0805" +l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" +l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" +l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" +l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" +l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" +l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" +l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" +l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" +l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" +l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" +l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" +l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" +l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" +l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" +l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" +l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" +l95 = "#f4ede7" +l96 = "#f7f0ea" +l97 = "#fbf4ee" +l98 = "#fef7f1" + +[savanna] +l10 = "#040301" +l11 = "#050502" +l12 = "#060603" +l13 = "#080704" +l14 = "#0a0905" +l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" +l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" +l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" +l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" +l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" +l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" +l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" +l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" +l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" +l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" +l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" +l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" +l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" +l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" +l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" +l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" +l95 = "#efefe7" +l96 = "#f3f2ea" +l97 = "#f6f6ed" +l98 = "#f9f9f1" + +[grassland] +l10 = "#020402" +l11 = "#030503" +l12 = "#040704" +l13 = "#050805" +l14 = "#060a07" +l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" +l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" +l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" +l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" +l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" +l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" +l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" +l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" +l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" +l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" +l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" +l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" +l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" +l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" +l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" +l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" +l95 = "#eaf1ea" +l96 = "#edf4ee" +l97 = "#f0f7f1" +l98 = "#f4fbf4" + +[tundra] +l10 = "#020306" +l11 = "#030408" +l12 = "#040609" +l13 = "#05070c" +l14 = "#07090e" +l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" +l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" +l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" +l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" +l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" +l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" +l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" +l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" +l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" +l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" +l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" +l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" +l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" +l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" +l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" +l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" +l95 = "#eaeff6" +l96 = "#eef2f9" +l97 = "#f1f5fd" +l98 = "#f5f9ff" + +[red] +l10 = "#0d0000" +l11 = "#100000" +l12 = "#130000" +l13 = "#170000" +l14 = "#1a0100" +l15 = "#1e0100" +l16 = "#220101" +l17 = "#250101" +l18 = "#290101" +l19 = "#2d0201" +l20 = "#310201" +l21 = "#350201" +l22 = "#390302" +l23 = "#3d0302" +l24 = "#410302" +l25 = "#450403" +l26 = "#490503" +l27 = "#4d0503" +l28 = "#510604" +l29 = "#560704" +l30 = "#5a0805" +l31 = "#5e0906" +l32 = "#620a06" +l33 = "#670b07" +l34 = "#6b0d08" +l35 = "#6f0e09" +l36 = "#740f0a" +l37 = "#78110b" +l38 = "#7d120c" +l39 = "#81140e" +l40 = "#85150f" +l41 = "#8a1710" +l42 = "#8e1912" +l43 = "#931a13" +l44 = "#971c15" +l45 = "#9b1e16" +l46 = "#a02018" +l47 = "#a4221a" +l48 = "#a8241c" +l49 = "#ad271d" +l50 = "#b1291f" +l51 = "#b52c22" +l52 = "#b92e24" +l53 = "#bd3126" +l54 = "#c13428" +l55 = "#c5372b" +l56 = "#c93a2e" +l57 = "#cd3d31" +l58 = "#d04034" +l59 = "#d44437" +l60 = "#d7473a" +l61 = "#db4b3d" +l62 = "#de4f41" +l63 = "#e15344" +l64 = "#e45748" +l65 = "#e65b4c" +l66 = "#e96050" +l67 = "#eb6454" +l68 = "#ee6859" +l69 = "#f06d5d" +l70 = "#f27262" +l71 = "#f47666" +l72 = "#f67b6b" +l73 = "#f77f70" +l74 = "#f98474" +l75 = "#fa8979" +l76 = "#fc8d7e" +l77 = "#fd9283" +l78 = "#fe9788" +l79 = "#ff9c8d" +l80 = "#ffa193" +l81 = "#ffa699" +l82 = "#ffab9e" +l83 = "#ffb0a4" +l84 = "#ffb5aa" +l85 = "#ffbaaf" +l86 = "#ffbfb5" +l87 = "#ffc4ba" +l88 = "#ffc8c0" +l89 = "#ffcdc5" +l90 = "#ffd2ca" +l91 = "#ffd6d0" +l92 = "#ffdbd5" +l93 = "#ffe0da" +l94 = "#ffe4e0" +l95 = "#ffe9e5" +l96 = "#ffedea" +l97 = "#fff2ef" +l98 = "#fff6f5" + +[orange] +l10 = "#070200" +l11 = "#090300" +l12 = "#0c0400" +l13 = "#0f0500" +l14 = "#120600" +l15 = "#140801" +l16 = "#170901" +l17 = "#1a0b01" +l18 = "#1d0d01" +l19 = "#200f01" +l20 = "#231101" +l21 = "#261302" +l22 = "#2a1502" +l23 = "#2d1702" +l24 = "#301903" +l25 = "#331b03" +l26 = "#361d03" +l27 = "#3a1f04" +l28 = "#3d2104" +l29 = "#402305" +l30 = "#442605" +l31 = "#472806" +l32 = "#4a2a07" +l33 = "#4e2c07" +l34 = "#512e08" +l35 = "#553109" +l36 = "#58330a" +l37 = "#5c350b" +l38 = "#5f380c" +l39 = "#633a0d" +l40 = "#673c0e" +l41 = "#6a3f0f" +l42 = "#6e4111" +l43 = "#714312" +l44 = "#754613" +l45 = "#794814" +l46 = "#7c4b16" +l47 = "#804d17" +l48 = "#845018" +l49 = "#87521a" +l50 = "#8b551b" +l51 = "#8f571d" +l52 = "#925a1f" +l53 = "#965c20" +l54 = "#9a5f22" +l55 = "#9d6224" +l56 = "#a16426" +l57 = "#a56728" +l58 = "#a86a2b" +l59 = "#ac6d2d" +l60 = "#af7030" +l61 = "#b37232" +l62 = "#b67535" +l63 = "#b97838" +l64 = "#bd7b3c" +l65 = "#c07e3f" +l66 = "#c38243" +l67 = "#c68547" +l68 = "#c9884b" +l69 = "#cc8b4f" +l70 = "#ce8f53" +l71 = "#d19258" +l72 = "#d3965d" +l73 = "#d69962" +l74 = "#d89d67" +l75 = "#daa06c" +l76 = "#dca471" +l77 = "#dea777" +l78 = "#e0ab7c" +l79 = "#e2af82" +l80 = "#e4b387" +l81 = "#e6b68d" +l82 = "#e7ba93" +l83 = "#e9be99" +l84 = "#ebc29e" +l85 = "#ecc5a4" +l86 = "#eec9aa" +l87 = "#efcdb0" +l88 = "#f1d1b6" +l89 = "#f2d5bc" +l90 = "#f3d9c2" +l91 = "#f5dcc8" +l92 = "#f6e0ce" +l93 = "#f7e4d4" +l94 = "#f8e8da" +l95 = "#faece0" +l96 = "#fbf0e6" +l97 = "#fcf3ec" +l98 = "#fdf7f3" + +[yellow] +l10 = "#040301" +l11 = "#050502" +l12 = "#060602" +l13 = "#080803" +l14 = "#0a0904" +l15 = "#0c0c04" +l16 = "#0e0e05" +l17 = "#111006" +l18 = "#131207" +l19 = "#151409" +l20 = "#18170a" +l21 = "#1a190c" +l22 = "#1c1b0d" +l23 = "#1f1e0f" +l24 = "#212011" +l25 = "#242212" +l26 = "#262514" +l27 = "#292715" +l28 = "#2b2a17" +l29 = "#2e2c19" +l30 = "#302f1b" +l31 = "#33311c" +l32 = "#36341e" +l33 = "#383620" +l34 = "#3b3921" +l35 = "#3e3c23" +l36 = "#403e25" +l37 = "#434127" +l38 = "#464429" +l39 = "#49462b" +l40 = "#4b492c" +l41 = "#4e4c2e" +l42 = "#514e30" +l43 = "#545132" +l44 = "#575434" +l45 = "#5a5736" +l46 = "#5c5a38" +l47 = "#5f5c3a" +l48 = "#625f3c" +l49 = "#65623e" +l50 = "#686540" +l51 = "#6b6842" +l52 = "#6e6b44" +l53 = "#716e46" +l54 = "#747149" +l55 = "#77744b" +l56 = "#7a764d" +l57 = "#7d794f" +l58 = "#807c51" +l59 = "#837f54" +l60 = "#868256" +l61 = "#898559" +l62 = "#8c885b" +l63 = "#8f8b5e" +l64 = "#928e60" +l65 = "#959263" +l66 = "#989566" +l67 = "#9c9869" +l68 = "#9f9b6c" +l69 = "#a29e6f" +l70 = "#a5a172" +l71 = "#a8a475" +l72 = "#aba779" +l73 = "#aeaa7c" +l74 = "#b1ad80" +l75 = "#b4b084" +l76 = "#b7b388" +l77 = "#bab78c" +l78 = "#bdba90" +l79 = "#c0bd95" +l80 = "#c3c099" +l81 = "#c6c39e" +l82 = "#c9c6a2" +l83 = "#ccc9a7" +l84 = "#cfccac" +l85 = "#d2d0b1" +l86 = "#d5d3b6" +l87 = "#d8d6bb" +l88 = "#dbd9c0" +l89 = "#dedcc5" +l90 = "#e1dfca" +l91 = "#e4e2cf" +l92 = "#e7e6d4" +l93 = "#eae9da" +l94 = "#edecdf" +l95 = "#f0efe4" +l96 = "#f3f2ea" +l97 = "#f6f5ef" +l98 = "#f9f9f4" + +[green] +l10 = "#010402" +l11 = "#020602" +l12 = "#020703" +l13 = "#030904" +l14 = "#040c05" +l15 = "#050e06" +l16 = "#061007" +l17 = "#071309" +l18 = "#08150a" +l19 = "#0a170c" +l20 = "#0c1a0e" +l21 = "#0d1c0f" +l22 = "#0f1f11" +l23 = "#102213" +l24 = "#122415" +l25 = "#142717" +l26 = "#162919" +l27 = "#172c1a" +l28 = "#192f1c" +l29 = "#1b321e" +l30 = "#1d3420" +l31 = "#1e3722" +l32 = "#203a24" +l33 = "#223d26" +l34 = "#243f28" +l35 = "#26422a" +l36 = "#28452c" +l37 = "#2a482e" +l38 = "#2c4b30" +l39 = "#2d4e32" +l40 = "#2f5134" +l41 = "#315437" +l42 = "#335739" +l43 = "#355a3b" +l44 = "#375d3d" +l45 = "#3a603f" +l46 = "#3c6341" +l47 = "#3e6644" +l48 = "#406946" +l49 = "#426c48" +l50 = "#446f4b" +l51 = "#46724d" +l52 = "#49754f" +l53 = "#4b7852" +l54 = "#4d7c54" +l55 = "#507f56" +l56 = "#528259" +l57 = "#54855b" +l58 = "#57885e" +l59 = "#598b60" +l60 = "#5c8e63" +l61 = "#5e9166" +l62 = "#619568" +l63 = "#64986b" +l64 = "#679b6e" +l65 = "#6a9e71" +l66 = "#6da174" +l67 = "#70a477" +l68 = "#73a77a" +l69 = "#76aa7d" +l70 = "#7aad81" +l71 = "#7db084" +l72 = "#81b388" +l73 = "#85b68b" +l74 = "#89b98f" +l75 = "#8dbc93" +l76 = "#91bf96" +l77 = "#95c29a" +l78 = "#99c49e" +l79 = "#9ec7a2" +l80 = "#a2caa6" +l81 = "#a6cdab" +l82 = "#abcfaf" +l83 = "#afd2b3" +l84 = "#b4d5b7" +l85 = "#b8d7bc" +l86 = "#bddac0" +l87 = "#c1ddc4" +l88 = "#c6dfc9" +l89 = "#cbe2cd" +l90 = "#cfe5d1" +l91 = "#d4e7d6" +l92 = "#d9eada" +l93 = "#deeddf" +l94 = "#e2efe3" +l95 = "#e7f2e8" +l96 = "#ecf5ed" +l97 = "#f1f7f1" +l98 = "#f5faf6" + +[blue] +l10 = "#01030c" +l11 = "#01040f" +l12 = "#020512" +l13 = "#020716" +l14 = "#020819" +l15 = "#030a1d" +l16 = "#040c20" +l17 = "#040e24" +l18 = "#051028" +l19 = "#06132b" +l20 = "#07152f" +l21 = "#081733" +l22 = "#0a1937" +l23 = "#0b1b3b" +l24 = "#0c1e3f" +l25 = "#0e2043" +l26 = "#0f2247" +l27 = "#11254b" +l28 = "#12274f" +l29 = "#142953" +l30 = "#152c57" +l31 = "#172e5b" +l32 = "#18315f" +l33 = "#1a3364" +l34 = "#1b3668" +l35 = "#1d386c" +l36 = "#1f3b70" +l37 = "#203d75" +l38 = "#224079" +l39 = "#24427d" +l40 = "#254582" +l41 = "#274886" +l42 = "#294a8a" +l43 = "#2b4d8e" +l44 = "#2c5093" +l45 = "#2e5297" +l46 = "#30559b" +l47 = "#3258a0" +l48 = "#345aa4" +l49 = "#365da8" +l50 = "#3860ad" +l51 = "#3a63b1" +l52 = "#3c66b5" +l53 = "#3e69b9" +l54 = "#416cbd" +l55 = "#436ec1" +l56 = "#4571c5" +l57 = "#4874c9" +l58 = "#4a77cd" +l59 = "#4d7ad1" +l60 = "#507dd4" +l61 = "#5280d8" +l62 = "#5584db" +l63 = "#5887de" +l64 = "#5b8ae1" +l65 = "#5f8de4" +l66 = "#6290e7" +l67 = "#6593ea" +l68 = "#6997ec" +l69 = "#6c9aee" +l70 = "#709df0" +l71 = "#74a0f2" +l72 = "#78a4f4" +l73 = "#7ca7f6" +l74 = "#80aaf7" +l75 = "#85aef9" +l76 = "#89b1fa" +l77 = "#8db4fb" +l78 = "#92b8fc" +l79 = "#96bbfd" +l80 = "#9bbefe" +l81 = "#a0c1fe" +l82 = "#a4c5ff" +l83 = "#aac8ff" +l84 = "#afcbff" +l85 = "#b4cfff" +l86 = "#b9d2ff" +l87 = "#bed5ff" +l88 = "#c3d8ff" +l89 = "#c8dcff" +l90 = "#cddfff" +l91 = "#d2e2ff" +l92 = "#d7e5ff" +l93 = "#dce9ff" +l94 = "#e1ecff" +l95 = "#e6efff" +l96 = "#ebf2ff" +l97 = "#f0f5ff" +l98 = "#f5f9ff" diff --git a/notebooks/palettes/monobiome-vUCC-oklch.json b/notebooks/palettes/monobiome-vUCC-oklch.json new file mode 100644 index 0000000..259a596 --- /dev/null +++ b/notebooks/palettes/monobiome-vUCC-oklch.json @@ -0,0 +1 @@ +{"alpine": {"l0": "oklch(0.0% 0.0000 0.0)", "l1": "oklch(1.0% 0.0000 0.0)", "l2": "oklch(2.0% 0.0000 0.0)", "l3": "oklch(3.0% 0.0000 0.0)", "l4": "oklch(4.0% 0.0000 0.0)", "l5": "oklch(5.0% 0.0000 0.0)", "l6": "oklch(6.0% 0.0000 0.0)", "l7": "oklch(7.0% 0.0000 0.0)", "l8": "oklch(8.0% 0.0000 0.0)", "l9": "oklch(9.0% 0.0000 0.0)", "l10": "oklch(10.0% 0.0000 0.0)", "l11": "oklch(11.0% 0.0000 0.0)", "l12": "oklch(12.0% 0.0000 0.0)", "l13": "oklch(13.0% 0.0000 0.0)", "l14": "oklch(14.0% 0.0000 0.0)", "l15": "oklch(15.0% 0.0000 0.0)", "l16": "oklch(16.0% 0.0000 0.0)", "l17": "oklch(17.0% 0.0000 0.0)", "l18": "oklch(18.0% 0.0000 0.0)", "l19": "oklch(19.0% 0.0000 0.0)", "l20": "oklch(20.0% 0.0000 0.0)", "l21": "oklch(21.0% 0.0000 0.0)", "l22": "oklch(22.0% 0.0000 0.0)", "l23": "oklch(23.0% 0.0000 0.0)", "l24": "oklch(24.0% 0.0000 0.0)", "l25": "oklch(25.0% 0.0000 0.0)", "l26": "oklch(26.0% 0.0000 0.0)", "l27": "oklch(27.0% 0.0000 0.0)", "l28": "oklch(28.0% 0.0000 0.0)", "l29": "oklch(29.0% 0.0000 0.0)", "l30": "oklch(30.0% 0.0000 0.0)", "l31": "oklch(31.0% 0.0000 0.0)", "l32": "oklch(32.0% 0.0000 0.0)", "l33": "oklch(33.0% 0.0000 0.0)", "l34": "oklch(34.0% 0.0000 0.0)", "l35": "oklch(35.0% 0.0000 0.0)", "l36": "oklch(36.0% 0.0000 0.0)", "l37": "oklch(37.0% 0.0000 0.0)", "l38": "oklch(38.0% 0.0000 0.0)", "l39": "oklch(39.0% 0.0000 0.0)", "l40": "oklch(40.0% 0.0000 0.0)", "l41": "oklch(41.0% 0.0000 0.0)", "l42": "oklch(42.0% 0.0000 0.0)", "l43": "oklch(43.0% 0.0000 0.0)", "l44": "oklch(44.0% 0.0000 0.0)", "l45": "oklch(45.0% 0.0000 0.0)", "l46": "oklch(46.0% 0.0000 0.0)", "l47": "oklch(47.0% 0.0000 0.0)", "l48": "oklch(48.0% 0.0000 0.0)", "l49": "oklch(49.0% 0.0000 0.0)", "l50": "oklch(50.0% 0.0000 0.0)", "l51": "oklch(51.0% 0.0000 0.0)", "l52": "oklch(52.0% 0.0000 0.0)", "l53": "oklch(53.0% 0.0000 0.0)", "l54": "oklch(54.0% 0.0000 0.0)", "l55": "oklch(55.0% 0.0000 0.0)", "l56": "oklch(56.0% 0.0000 0.0)", "l57": "oklch(57.0% 0.0000 0.0)", "l58": "oklch(58.0% 0.0000 0.0)", "l59": "oklch(59.0% 0.0000 0.0)", "l60": "oklch(60.0% 0.0000 0.0)", "l61": "oklch(61.0% 0.0000 0.0)", "l62": "oklch(62.0% 0.0000 0.0)", "l63": "oklch(63.0% 0.0000 0.0)", "l64": "oklch(64.0% 0.0000 0.0)", "l65": "oklch(65.0% 0.0000 0.0)", "l66": "oklch(66.0% 0.0000 0.0)", "l67": "oklch(67.0% 0.0000 0.0)", "l68": "oklch(68.0% 0.0000 0.0)", "l69": "oklch(69.0% 0.0000 0.0)", "l70": "oklch(70.0% 0.0000 0.0)", "l71": "oklch(71.0% 0.0000 0.0)", "l72": "oklch(72.0% 0.0000 0.0)", "l73": "oklch(73.0% 0.0000 0.0)", "l74": "oklch(74.0% 0.0000 0.0)", "l75": "oklch(75.0% 0.0000 0.0)", "l76": "oklch(76.0% 0.0000 0.0)", "l77": "oklch(77.0% 0.0000 0.0)", "l78": "oklch(78.0% 0.0000 0.0)", "l79": "oklch(79.0% 0.0000 0.0)", "l80": "oklch(80.0% 0.0000 0.0)", "l81": "oklch(81.0% 0.0000 0.0)", "l82": "oklch(82.0% 0.0000 0.0)", "l83": "oklch(83.0% 0.0000 0.0)", "l84": "oklch(84.0% 0.0000 0.0)", "l85": "oklch(85.0% 0.0000 0.0)", "l86": "oklch(86.0% 0.0000 0.0)", "l87": "oklch(87.0% 0.0000 0.0)", "l88": "oklch(88.0% 0.0000 0.0)", "l89": "oklch(89.0% 0.0000 0.0)", "l90": "oklch(90.0% 0.0000 0.0)", "l91": "oklch(91.0% 0.0000 0.0)", "l92": "oklch(92.0% 0.0000 0.0)", "l93": "oklch(93.0% 0.0000 0.0)", "l94": "oklch(94.0% 0.0000 0.0)", "l95": "oklch(95.0% 0.0000 0.0)", "l96": "oklch(96.0% 0.0000 0.0)", "l97": "oklch(97.0% 0.0000 0.0)", "l98": "oklch(98.0% 0.0000 0.0)", "l99": "oklch(99.0% 0.0000 0.0)", "l100": "oklch(100.0% 0.0000 0.0)"}, "badlands": {"l0": "oklch(0.0% 0.0110 29.0)", "l1": "oklch(1.0% 0.0110 29.0)", "l2": "oklch(2.0% 0.0110 29.0)", "l3": "oklch(3.0% 0.0110 29.0)", "l4": "oklch(4.0% 0.0110 29.0)", "l5": "oklch(5.0% 0.0110 29.0)", "l6": "oklch(6.0% 0.0110 29.0)", "l7": "oklch(7.0% 0.0110 29.0)", "l8": "oklch(8.0% 0.0110 29.0)", "l9": "oklch(9.0% 0.0110 29.0)", "l10": "oklch(10.0% 0.0110 29.0)", "l11": "oklch(11.0% 0.0110 29.0)", "l12": "oklch(12.0% 0.0110 29.0)", "l13": "oklch(13.0% 0.0110 29.0)", "l14": "oklch(14.0% 0.0110 29.0)", "l15": "oklch(15.0% 0.0110 29.0)", "l16": "oklch(16.0% 0.0110 29.0)", "l17": "oklch(17.0% 0.0110 29.0)", "l18": "oklch(18.0% 0.0110 29.0)", "l19": "oklch(19.0% 0.0110 29.0)", "l20": "oklch(20.0% 0.0110 29.0)", "l21": "oklch(21.0% 0.0110 29.0)", "l22": "oklch(22.0% 0.0110 29.0)", "l23": "oklch(23.0% 0.0110 29.0)", "l24": "oklch(24.0% 0.0110 29.0)", "l25": "oklch(25.0% 0.0110 29.0)", "l26": "oklch(26.0% 0.0110 29.0)", "l27": "oklch(27.0% 0.0110 29.0)", "l28": "oklch(28.0% 0.0110 29.0)", "l29": "oklch(29.0% 0.0110 29.0)", "l30": "oklch(30.0% 0.0110 29.0)", "l31": "oklch(31.0% 0.0110 29.0)", "l32": "oklch(32.0% 0.0110 29.0)", "l33": "oklch(33.0% 0.0110 29.0)", "l34": "oklch(34.0% 0.0110 29.0)", "l35": "oklch(35.0% 0.0110 29.0)", "l36": "oklch(36.0% 0.0110 29.0)", "l37": "oklch(37.0% 0.0110 29.0)", "l38": "oklch(38.0% 0.0110 29.0)", "l39": "oklch(39.0% 0.0110 29.0)", "l40": "oklch(40.0% 0.0110 29.0)", "l41": "oklch(41.0% 0.0110 29.0)", "l42": "oklch(42.0% 0.0110 29.0)", "l43": "oklch(43.0% 0.0110 29.0)", "l44": "oklch(44.0% 0.0110 29.0)", "l45": "oklch(45.0% 0.0110 29.0)", "l46": "oklch(46.0% 0.0110 29.0)", "l47": "oklch(47.0% 0.0110 29.0)", "l48": "oklch(48.0% 0.0110 29.0)", "l49": "oklch(49.0% 0.0110 29.0)", "l50": "oklch(50.0% 0.0110 29.0)", "l51": "oklch(51.0% 0.0110 29.0)", "l52": "oklch(52.0% 0.0110 29.0)", "l53": "oklch(53.0% 0.0110 29.0)", "l54": "oklch(54.0% 0.0110 29.0)", "l55": "oklch(55.0% 0.0110 29.0)", "l56": "oklch(56.0% 0.0110 29.0)", "l57": "oklch(57.0% 0.0110 29.0)", "l58": "oklch(58.0% 0.0110 29.0)", "l59": "oklch(59.0% 0.0110 29.0)", "l60": "oklch(60.0% 0.0110 29.0)", "l61": "oklch(61.0% 0.0110 29.0)", "l62": "oklch(62.0% 0.0110 29.0)", "l63": "oklch(63.0% 0.0110 29.0)", "l64": "oklch(64.0% 0.0110 29.0)", "l65": "oklch(65.0% 0.0110 29.0)", "l66": "oklch(66.0% 0.0110 29.0)", "l67": "oklch(67.0% 0.0110 29.0)", "l68": "oklch(68.0% 0.0110 29.0)", "l69": "oklch(69.0% 0.0110 29.0)", "l70": "oklch(70.0% 0.0110 29.0)", "l71": "oklch(71.0% 0.0110 29.0)", "l72": "oklch(72.0% 0.0110 29.0)", "l73": "oklch(73.0% 0.0110 29.0)", "l74": "oklch(74.0% 0.0110 29.0)", "l75": "oklch(75.0% 0.0110 29.0)", "l76": "oklch(76.0% 0.0110 29.0)", "l77": "oklch(77.0% 0.0110 29.0)", "l78": "oklch(78.0% 0.0110 29.0)", "l79": "oklch(79.0% 0.0110 29.0)", "l80": "oklch(80.0% 0.0110 29.0)", "l81": "oklch(81.0% 0.0110 29.0)", "l82": "oklch(82.0% 0.0110 29.0)", "l83": "oklch(83.0% 0.0110 29.0)", "l84": "oklch(84.0% 0.0110 29.0)", "l85": "oklch(85.0% 0.0110 29.0)", "l86": "oklch(86.0% 0.0110 29.0)", "l87": "oklch(87.0% 0.0110 29.0)", "l88": "oklch(88.0% 0.0110 29.0)", "l89": "oklch(89.0% 0.0110 29.0)", "l90": "oklch(90.0% 0.0110 29.0)", "l91": "oklch(91.0% 0.0110 29.0)", "l92": "oklch(92.0% 0.0110 29.0)", "l93": "oklch(93.0% 0.0110 29.0)", "l94": "oklch(94.0% 0.0110 29.0)", "l95": "oklch(95.0% 0.0110 29.0)", "l96": "oklch(96.0% 0.0110 29.0)", "l97": "oklch(97.0% 0.0110 29.0)", "l98": "oklch(98.0% 0.0110 29.0)", "l99": "oklch(99.0% 0.0110 29.0)", "l100": "oklch(100.0% 0.0110 29.0)"}, "chaparral": {"l0": "oklch(0.0% 0.0110 62.5)", "l1": "oklch(1.0% 0.0110 62.5)", "l2": "oklch(2.0% 0.0110 62.5)", "l3": "oklch(3.0% 0.0110 62.5)", "l4": "oklch(4.0% 0.0110 62.5)", "l5": "oklch(5.0% 0.0110 62.5)", "l6": "oklch(6.0% 0.0110 62.5)", "l7": "oklch(7.0% 0.0110 62.5)", "l8": "oklch(8.0% 0.0110 62.5)", "l9": "oklch(9.0% 0.0110 62.5)", "l10": "oklch(10.0% 0.0110 62.5)", "l11": "oklch(11.0% 0.0110 62.5)", "l12": "oklch(12.0% 0.0110 62.5)", "l13": "oklch(13.0% 0.0110 62.5)", "l14": "oklch(14.0% 0.0110 62.5)", "l15": "oklch(15.0% 0.0110 62.5)", "l16": "oklch(16.0% 0.0110 62.5)", "l17": "oklch(17.0% 0.0110 62.5)", "l18": "oklch(18.0% 0.0110 62.5)", "l19": "oklch(19.0% 0.0110 62.5)", "l20": "oklch(20.0% 0.0110 62.5)", "l21": "oklch(21.0% 0.0110 62.5)", "l22": "oklch(22.0% 0.0110 62.5)", "l23": "oklch(23.0% 0.0110 62.5)", "l24": "oklch(24.0% 0.0110 62.5)", "l25": "oklch(25.0% 0.0110 62.5)", "l26": "oklch(26.0% 0.0110 62.5)", "l27": "oklch(27.0% 0.0110 62.5)", "l28": "oklch(28.0% 0.0110 62.5)", "l29": "oklch(29.0% 0.0110 62.5)", "l30": "oklch(30.0% 0.0110 62.5)", "l31": "oklch(31.0% 0.0110 62.5)", "l32": "oklch(32.0% 0.0110 62.5)", "l33": "oklch(33.0% 0.0110 62.5)", "l34": "oklch(34.0% 0.0110 62.5)", "l35": "oklch(35.0% 0.0110 62.5)", "l36": "oklch(36.0% 0.0110 62.5)", "l37": "oklch(37.0% 0.0110 62.5)", "l38": "oklch(38.0% 0.0110 62.5)", "l39": "oklch(39.0% 0.0110 62.5)", "l40": "oklch(40.0% 0.0110 62.5)", "l41": "oklch(41.0% 0.0110 62.5)", "l42": "oklch(42.0% 0.0110 62.5)", "l43": "oklch(43.0% 0.0110 62.5)", "l44": "oklch(44.0% 0.0110 62.5)", "l45": "oklch(45.0% 0.0110 62.5)", "l46": "oklch(46.0% 0.0110 62.5)", "l47": "oklch(47.0% 0.0110 62.5)", "l48": "oklch(48.0% 0.0110 62.5)", "l49": "oklch(49.0% 0.0110 62.5)", "l50": "oklch(50.0% 0.0110 62.5)", "l51": "oklch(51.0% 0.0110 62.5)", "l52": "oklch(52.0% 0.0110 62.5)", "l53": "oklch(53.0% 0.0110 62.5)", "l54": "oklch(54.0% 0.0110 62.5)", "l55": "oklch(55.0% 0.0110 62.5)", "l56": "oklch(56.0% 0.0110 62.5)", "l57": "oklch(57.0% 0.0110 62.5)", "l58": "oklch(58.0% 0.0110 62.5)", "l59": "oklch(59.0% 0.0110 62.5)", "l60": "oklch(60.0% 0.0110 62.5)", "l61": "oklch(61.0% 0.0110 62.5)", "l62": "oklch(62.0% 0.0110 62.5)", "l63": "oklch(63.0% 0.0110 62.5)", "l64": "oklch(64.0% 0.0110 62.5)", "l65": "oklch(65.0% 0.0110 62.5)", "l66": "oklch(66.0% 0.0110 62.5)", "l67": "oklch(67.0% 0.0110 62.5)", "l68": "oklch(68.0% 0.0110 62.5)", "l69": "oklch(69.0% 0.0110 62.5)", "l70": "oklch(70.0% 0.0110 62.5)", "l71": "oklch(71.0% 0.0110 62.5)", "l72": "oklch(72.0% 0.0110 62.5)", "l73": "oklch(73.0% 0.0110 62.5)", "l74": "oklch(74.0% 0.0110 62.5)", "l75": "oklch(75.0% 0.0110 62.5)", "l76": "oklch(76.0% 0.0110 62.5)", "l77": "oklch(77.0% 0.0110 62.5)", "l78": "oklch(78.0% 0.0110 62.5)", "l79": "oklch(79.0% 0.0110 62.5)", "l80": "oklch(80.0% 0.0110 62.5)", "l81": "oklch(81.0% 0.0110 62.5)", "l82": "oklch(82.0% 0.0110 62.5)", "l83": "oklch(83.0% 0.0110 62.5)", "l84": "oklch(84.0% 0.0110 62.5)", "l85": "oklch(85.0% 0.0110 62.5)", "l86": "oklch(86.0% 0.0110 62.5)", "l87": "oklch(87.0% 0.0110 62.5)", "l88": "oklch(88.0% 0.0110 62.5)", "l89": "oklch(89.0% 0.0110 62.5)", "l90": "oklch(90.0% 0.0110 62.5)", "l91": "oklch(91.0% 0.0110 62.5)", "l92": "oklch(92.0% 0.0110 62.5)", "l93": "oklch(93.0% 0.0110 62.5)", "l94": "oklch(94.0% 0.0110 62.5)", "l95": "oklch(95.0% 0.0110 62.5)", "l96": "oklch(96.0% 0.0110 62.5)", "l97": "oklch(97.0% 0.0110 62.5)", "l98": "oklch(98.0% 0.0110 62.5)", "l99": "oklch(99.0% 0.0110 62.5)", "l100": "oklch(100.0% 0.0110 62.5)"}, "savanna": {"l0": "oklch(0.0% 0.0110 104.0)", "l1": "oklch(1.0% 0.0110 104.0)", "l2": "oklch(2.0% 0.0110 104.0)", "l3": "oklch(3.0% 0.0110 104.0)", "l4": "oklch(4.0% 0.0110 104.0)", "l5": "oklch(5.0% 0.0110 104.0)", "l6": "oklch(6.0% 0.0110 104.0)", "l7": "oklch(7.0% 0.0110 104.0)", "l8": "oklch(8.0% 0.0110 104.0)", "l9": "oklch(9.0% 0.0110 104.0)", "l10": "oklch(10.0% 0.0110 104.0)", "l11": "oklch(11.0% 0.0110 104.0)", "l12": "oklch(12.0% 0.0110 104.0)", "l13": "oklch(13.0% 0.0110 104.0)", "l14": "oklch(14.0% 0.0110 104.0)", "l15": "oklch(15.0% 0.0110 104.0)", "l16": "oklch(16.0% 0.0110 104.0)", "l17": "oklch(17.0% 0.0110 104.0)", "l18": "oklch(18.0% 0.0110 104.0)", "l19": "oklch(19.0% 0.0110 104.0)", "l20": "oklch(20.0% 0.0110 104.0)", "l21": "oklch(21.0% 0.0110 104.0)", "l22": "oklch(22.0% 0.0110 104.0)", "l23": "oklch(23.0% 0.0110 104.0)", "l24": "oklch(24.0% 0.0110 104.0)", "l25": "oklch(25.0% 0.0110 104.0)", "l26": "oklch(26.0% 0.0110 104.0)", "l27": "oklch(27.0% 0.0110 104.0)", "l28": "oklch(28.0% 0.0110 104.0)", "l29": "oklch(29.0% 0.0110 104.0)", "l30": "oklch(30.0% 0.0110 104.0)", "l31": "oklch(31.0% 0.0110 104.0)", "l32": "oklch(32.0% 0.0110 104.0)", "l33": "oklch(33.0% 0.0110 104.0)", "l34": "oklch(34.0% 0.0110 104.0)", "l35": "oklch(35.0% 0.0110 104.0)", "l36": "oklch(36.0% 0.0110 104.0)", "l37": "oklch(37.0% 0.0110 104.0)", "l38": "oklch(38.0% 0.0110 104.0)", "l39": "oklch(39.0% 0.0110 104.0)", "l40": "oklch(40.0% 0.0110 104.0)", "l41": "oklch(41.0% 0.0110 104.0)", "l42": "oklch(42.0% 0.0110 104.0)", "l43": "oklch(43.0% 0.0110 104.0)", "l44": "oklch(44.0% 0.0110 104.0)", "l45": "oklch(45.0% 0.0110 104.0)", "l46": "oklch(46.0% 0.0110 104.0)", "l47": "oklch(47.0% 0.0110 104.0)", "l48": "oklch(48.0% 0.0110 104.0)", "l49": "oklch(49.0% 0.0110 104.0)", "l50": "oklch(50.0% 0.0110 104.0)", "l51": "oklch(51.0% 0.0110 104.0)", "l52": "oklch(52.0% 0.0110 104.0)", "l53": "oklch(53.0% 0.0110 104.0)", "l54": "oklch(54.0% 0.0110 104.0)", "l55": "oklch(55.0% 0.0110 104.0)", "l56": "oklch(56.0% 0.0110 104.0)", "l57": "oklch(57.0% 0.0110 104.0)", "l58": "oklch(58.0% 0.0110 104.0)", "l59": "oklch(59.0% 0.0110 104.0)", "l60": "oklch(60.0% 0.0110 104.0)", "l61": "oklch(61.0% 0.0110 104.0)", "l62": "oklch(62.0% 0.0110 104.0)", "l63": "oklch(63.0% 0.0110 104.0)", "l64": "oklch(64.0% 0.0110 104.0)", "l65": "oklch(65.0% 0.0110 104.0)", "l66": "oklch(66.0% 0.0110 104.0)", "l67": "oklch(67.0% 0.0110 104.0)", "l68": "oklch(68.0% 0.0110 104.0)", "l69": "oklch(69.0% 0.0110 104.0)", "l70": "oklch(70.0% 0.0110 104.0)", "l71": "oklch(71.0% 0.0110 104.0)", "l72": "oklch(72.0% 0.0110 104.0)", "l73": "oklch(73.0% 0.0110 104.0)", "l74": "oklch(74.0% 0.0110 104.0)", "l75": "oklch(75.0% 0.0110 104.0)", "l76": "oklch(76.0% 0.0110 104.0)", "l77": "oklch(77.0% 0.0110 104.0)", "l78": "oklch(78.0% 0.0110 104.0)", "l79": "oklch(79.0% 0.0110 104.0)", "l80": "oklch(80.0% 0.0110 104.0)", "l81": "oklch(81.0% 0.0110 104.0)", "l82": "oklch(82.0% 0.0110 104.0)", "l83": "oklch(83.0% 0.0110 104.0)", "l84": "oklch(84.0% 0.0110 104.0)", "l85": "oklch(85.0% 0.0110 104.0)", "l86": "oklch(86.0% 0.0110 104.0)", "l87": "oklch(87.0% 0.0110 104.0)", "l88": "oklch(88.0% 0.0110 104.0)", "l89": "oklch(89.0% 0.0110 104.0)", "l90": "oklch(90.0% 0.0110 104.0)", "l91": "oklch(91.0% 0.0110 104.0)", "l92": "oklch(92.0% 0.0110 104.0)", "l93": "oklch(93.0% 0.0110 104.0)", "l94": "oklch(94.0% 0.0110 104.0)", "l95": "oklch(95.0% 0.0110 104.0)", "l96": "oklch(96.0% 0.0110 104.0)", "l97": "oklch(97.0% 0.0110 104.0)", "l98": "oklch(98.0% 0.0110 104.0)", "l99": "oklch(99.0% 0.0110 104.0)", "l100": "oklch(100.0% 0.0110 104.0)"}, "grassland": {"l0": "oklch(0.0% 0.0110 148.0)", "l1": "oklch(1.0% 0.0110 148.0)", "l2": "oklch(2.0% 0.0110 148.0)", "l3": "oklch(3.0% 0.0110 148.0)", "l4": "oklch(4.0% 0.0110 148.0)", "l5": "oklch(5.0% 0.0110 148.0)", "l6": "oklch(6.0% 0.0110 148.0)", "l7": "oklch(7.0% 0.0110 148.0)", "l8": "oklch(8.0% 0.0110 148.0)", "l9": "oklch(9.0% 0.0110 148.0)", "l10": "oklch(10.0% 0.0110 148.0)", "l11": "oklch(11.0% 0.0110 148.0)", "l12": "oklch(12.0% 0.0110 148.0)", "l13": "oklch(13.0% 0.0110 148.0)", "l14": "oklch(14.0% 0.0110 148.0)", "l15": "oklch(15.0% 0.0110 148.0)", "l16": "oklch(16.0% 0.0110 148.0)", "l17": "oklch(17.0% 0.0110 148.0)", "l18": "oklch(18.0% 0.0110 148.0)", "l19": "oklch(19.0% 0.0110 148.0)", "l20": "oklch(20.0% 0.0110 148.0)", "l21": "oklch(21.0% 0.0110 148.0)", "l22": "oklch(22.0% 0.0110 148.0)", "l23": "oklch(23.0% 0.0110 148.0)", "l24": "oklch(24.0% 0.0110 148.0)", "l25": "oklch(25.0% 0.0110 148.0)", "l26": "oklch(26.0% 0.0110 148.0)", "l27": "oklch(27.0% 0.0110 148.0)", "l28": "oklch(28.0% 0.0110 148.0)", "l29": "oklch(29.0% 0.0110 148.0)", "l30": "oklch(30.0% 0.0110 148.0)", "l31": "oklch(31.0% 0.0110 148.0)", "l32": "oklch(32.0% 0.0110 148.0)", "l33": "oklch(33.0% 0.0110 148.0)", "l34": "oklch(34.0% 0.0110 148.0)", "l35": "oklch(35.0% 0.0110 148.0)", "l36": "oklch(36.0% 0.0110 148.0)", "l37": "oklch(37.0% 0.0110 148.0)", "l38": "oklch(38.0% 0.0110 148.0)", "l39": "oklch(39.0% 0.0110 148.0)", "l40": "oklch(40.0% 0.0110 148.0)", "l41": "oklch(41.0% 0.0110 148.0)", "l42": "oklch(42.0% 0.0110 148.0)", "l43": "oklch(43.0% 0.0110 148.0)", "l44": "oklch(44.0% 0.0110 148.0)", "l45": "oklch(45.0% 0.0110 148.0)", "l46": "oklch(46.0% 0.0110 148.0)", "l47": "oklch(47.0% 0.0110 148.0)", "l48": "oklch(48.0% 0.0110 148.0)", "l49": "oklch(49.0% 0.0110 148.0)", "l50": "oklch(50.0% 0.0110 148.0)", "l51": "oklch(51.0% 0.0110 148.0)", "l52": "oklch(52.0% 0.0110 148.0)", "l53": "oklch(53.0% 0.0110 148.0)", "l54": "oklch(54.0% 0.0110 148.0)", "l55": "oklch(55.0% 0.0110 148.0)", "l56": "oklch(56.0% 0.0110 148.0)", "l57": "oklch(57.0% 0.0110 148.0)", "l58": "oklch(58.0% 0.0110 148.0)", "l59": "oklch(59.0% 0.0110 148.0)", "l60": "oklch(60.0% 0.0110 148.0)", "l61": "oklch(61.0% 0.0110 148.0)", "l62": "oklch(62.0% 0.0110 148.0)", "l63": "oklch(63.0% 0.0110 148.0)", "l64": "oklch(64.0% 0.0110 148.0)", "l65": "oklch(65.0% 0.0110 148.0)", "l66": "oklch(66.0% 0.0110 148.0)", "l67": "oklch(67.0% 0.0110 148.0)", "l68": "oklch(68.0% 0.0110 148.0)", "l69": "oklch(69.0% 0.0110 148.0)", "l70": "oklch(70.0% 0.0110 148.0)", "l71": "oklch(71.0% 0.0110 148.0)", "l72": "oklch(72.0% 0.0110 148.0)", "l73": "oklch(73.0% 0.0110 148.0)", "l74": "oklch(74.0% 0.0110 148.0)", "l75": "oklch(75.0% 0.0110 148.0)", "l76": "oklch(76.0% 0.0110 148.0)", "l77": "oklch(77.0% 0.0110 148.0)", "l78": "oklch(78.0% 0.0110 148.0)", "l79": "oklch(79.0% 0.0110 148.0)", "l80": "oklch(80.0% 0.0110 148.0)", "l81": "oklch(81.0% 0.0110 148.0)", "l82": "oklch(82.0% 0.0110 148.0)", "l83": "oklch(83.0% 0.0110 148.0)", "l84": "oklch(84.0% 0.0110 148.0)", "l85": "oklch(85.0% 0.0110 148.0)", "l86": "oklch(86.0% 0.0110 148.0)", "l87": "oklch(87.0% 0.0110 148.0)", "l88": "oklch(88.0% 0.0110 148.0)", "l89": "oklch(89.0% 0.0110 148.0)", "l90": "oklch(90.0% 0.0110 148.0)", "l91": "oklch(91.0% 0.0110 148.0)", "l92": "oklch(92.0% 0.0110 148.0)", "l93": "oklch(93.0% 0.0110 148.0)", "l94": "oklch(94.0% 0.0110 148.0)", "l95": "oklch(95.0% 0.0110 148.0)", "l96": "oklch(96.0% 0.0110 148.0)", "l97": "oklch(97.0% 0.0110 148.0)", "l98": "oklch(98.0% 0.0110 148.0)", "l99": "oklch(99.0% 0.0110 148.0)", "l100": "oklch(100.0% 0.0110 148.0)"}, "tundra": {"l0": "oklch(0.0% 0.0110 262.0)", "l1": "oklch(1.0% 0.0110 262.0)", "l2": "oklch(2.0% 0.0110 262.0)", "l3": "oklch(3.0% 0.0110 262.0)", "l4": "oklch(4.0% 0.0110 262.0)", "l5": "oklch(5.0% 0.0110 262.0)", "l6": "oklch(6.0% 0.0110 262.0)", "l7": "oklch(7.0% 0.0110 262.0)", "l8": "oklch(8.0% 0.0110 262.0)", "l9": "oklch(9.0% 0.0110 262.0)", "l10": "oklch(10.0% 0.0110 262.0)", "l11": "oklch(11.0% 0.0110 262.0)", "l12": "oklch(12.0% 0.0110 262.0)", "l13": "oklch(13.0% 0.0110 262.0)", "l14": "oklch(14.0% 0.0110 262.0)", "l15": "oklch(15.0% 0.0110 262.0)", "l16": "oklch(16.0% 0.0110 262.0)", "l17": "oklch(17.0% 0.0110 262.0)", "l18": "oklch(18.0% 0.0110 262.0)", "l19": "oklch(19.0% 0.0110 262.0)", "l20": "oklch(20.0% 0.0110 262.0)", "l21": "oklch(21.0% 0.0110 262.0)", "l22": "oklch(22.0% 0.0110 262.0)", "l23": "oklch(23.0% 0.0110 262.0)", "l24": "oklch(24.0% 0.0110 262.0)", "l25": "oklch(25.0% 0.0110 262.0)", "l26": "oklch(26.0% 0.0110 262.0)", "l27": "oklch(27.0% 0.0110 262.0)", "l28": "oklch(28.0% 0.0110 262.0)", "l29": "oklch(29.0% 0.0110 262.0)", "l30": "oklch(30.0% 0.0110 262.0)", "l31": "oklch(31.0% 0.0110 262.0)", "l32": "oklch(32.0% 0.0110 262.0)", "l33": "oklch(33.0% 0.0110 262.0)", "l34": "oklch(34.0% 0.0110 262.0)", "l35": "oklch(35.0% 0.0110 262.0)", "l36": "oklch(36.0% 0.0110 262.0)", "l37": "oklch(37.0% 0.0110 262.0)", "l38": "oklch(38.0% 0.0110 262.0)", "l39": "oklch(39.0% 0.0110 262.0)", "l40": "oklch(40.0% 0.0110 262.0)", "l41": "oklch(41.0% 0.0110 262.0)", "l42": "oklch(42.0% 0.0110 262.0)", "l43": "oklch(43.0% 0.0110 262.0)", "l44": "oklch(44.0% 0.0110 262.0)", "l45": "oklch(45.0% 0.0110 262.0)", "l46": "oklch(46.0% 0.0110 262.0)", "l47": "oklch(47.0% 0.0110 262.0)", "l48": "oklch(48.0% 0.0110 262.0)", "l49": "oklch(49.0% 0.0110 262.0)", "l50": "oklch(50.0% 0.0110 262.0)", "l51": "oklch(51.0% 0.0110 262.0)", "l52": "oklch(52.0% 0.0110 262.0)", "l53": "oklch(53.0% 0.0110 262.0)", "l54": "oklch(54.0% 0.0110 262.0)", "l55": "oklch(55.0% 0.0110 262.0)", "l56": "oklch(56.0% 0.0110 262.0)", "l57": "oklch(57.0% 0.0110 262.0)", "l58": "oklch(58.0% 0.0110 262.0)", "l59": "oklch(59.0% 0.0110 262.0)", "l60": "oklch(60.0% 0.0110 262.0)", "l61": "oklch(61.0% 0.0110 262.0)", "l62": "oklch(62.0% 0.0110 262.0)", "l63": "oklch(63.0% 0.0110 262.0)", "l64": "oklch(64.0% 0.0110 262.0)", "l65": "oklch(65.0% 0.0110 262.0)", "l66": "oklch(66.0% 0.0110 262.0)", "l67": "oklch(67.0% 0.0110 262.0)", "l68": "oklch(68.0% 0.0110 262.0)", "l69": "oklch(69.0% 0.0110 262.0)", "l70": "oklch(70.0% 0.0110 262.0)", "l71": "oklch(71.0% 0.0110 262.0)", "l72": "oklch(72.0% 0.0110 262.0)", "l73": "oklch(73.0% 0.0110 262.0)", "l74": "oklch(74.0% 0.0110 262.0)", "l75": "oklch(75.0% 0.0110 262.0)", "l76": "oklch(76.0% 0.0110 262.0)", "l77": "oklch(77.0% 0.0110 262.0)", "l78": "oklch(78.0% 0.0110 262.0)", "l79": "oklch(79.0% 0.0110 262.0)", "l80": "oklch(80.0% 0.0110 262.0)", "l81": "oklch(81.0% 0.0110 262.0)", "l82": "oklch(82.0% 0.0110 262.0)", "l83": "oklch(83.0% 0.0110 262.0)", "l84": "oklch(84.0% 0.0110 262.0)", "l85": "oklch(85.0% 0.0110 262.0)", "l86": "oklch(86.0% 0.0110 262.0)", "l87": "oklch(87.0% 0.0110 262.0)", "l88": "oklch(88.0% 0.0110 262.0)", "l89": "oklch(89.0% 0.0110 262.0)", "l90": "oklch(90.0% 0.0110 262.0)", "l91": "oklch(91.0% 0.0110 262.0)", "l92": "oklch(92.0% 0.0110 262.0)", "l93": "oklch(93.0% 0.0110 262.0)", "l94": "oklch(94.0% 0.0110 262.0)", "l95": "oklch(95.0% 0.0110 262.0)", "l96": "oklch(96.0% 0.0110 262.0)", "l97": "oklch(97.0% 0.0110 262.0)", "l98": "oklch(98.0% 0.0110 262.0)", "l99": "oklch(99.0% 0.0110 262.0)", "l100": "oklch(100.0% 0.0110 262.0)"}, "red": {"l0": "oklch(0.0% 0.0315 29.0)", "l1": "oklch(1.0% 0.0315 29.0)", "l2": "oklch(2.0% 0.0315 29.0)", "l3": "oklch(3.0% 0.0315 29.0)", "l4": "oklch(4.0% 0.0315 29.0)", "l5": "oklch(5.0% 0.0315 29.0)", "l6": "oklch(6.0% 0.0315 29.0)", "l7": "oklch(7.0% 0.0315 29.0)", "l8": "oklch(8.0% 0.0315 29.0)", "l9": "oklch(9.0% 0.0315 29.0)", "l10": "oklch(10.0% 0.0315 29.0)", "l11": "oklch(11.0% 0.0315 29.0)", "l12": "oklch(12.0% 0.0315 29.0)", "l13": "oklch(13.0% 0.0315 29.0)", "l14": "oklch(14.0% 0.0315 29.0)", "l15": "oklch(15.0% 0.0315 29.0)", "l16": "oklch(16.0% 0.0336 29.0)", "l17": "oklch(17.0% 0.0357 29.0)", "l18": "oklch(18.0% 0.0378 29.0)", "l19": "oklch(19.0% 0.0400 29.0)", "l20": "oklch(20.0% 0.0421 29.0)", "l21": "oklch(21.0% 0.0442 29.0)", "l22": "oklch(22.0% 0.0463 29.0)", "l23": "oklch(23.0% 0.0484 29.0)", "l24": "oklch(24.0% 0.0505 29.0)", "l25": "oklch(25.0% 0.0526 29.0)", "l26": "oklch(26.0% 0.0547 29.0)", "l27": "oklch(27.0% 0.0568 29.0)", "l28": "oklch(28.0% 0.0589 29.0)", "l29": "oklch(29.0% 0.0610 29.0)", "l30": "oklch(30.0% 0.0631 29.0)", "l31": "oklch(31.0% 0.0652 29.0)", "l32": "oklch(32.0% 0.0672 29.0)", "l33": "oklch(33.0% 0.0693 29.0)", "l34": "oklch(34.0% 0.0714 29.0)", "l35": "oklch(35.0% 0.0735 29.0)", "l36": "oklch(36.0% 0.0755 29.0)", "l37": "oklch(37.0% 0.0776 29.0)", "l38": "oklch(38.0% 0.0797 29.0)", "l39": "oklch(39.0% 0.0817 29.0)", "l40": "oklch(40.0% 0.0838 29.0)", "l41": "oklch(41.0% 0.0858 29.0)", "l42": "oklch(42.0% 0.0879 29.0)", "l43": "oklch(43.0% 0.0899 29.0)", "l44": "oklch(44.0% 0.0919 29.0)", "l45": "oklch(45.0% 0.0939 29.0)", "l46": "oklch(46.0% 0.0959 29.0)", "l47": "oklch(47.0% 0.0979 29.0)", "l48": "oklch(48.0% 0.0999 29.0)", "l49": "oklch(49.0% 0.1019 29.0)", "l50": "oklch(50.0% 0.1038 29.0)", "l51": "oklch(51.0% 0.1058 29.0)", "l52": "oklch(52.0% 0.1077 29.0)", "l53": "oklch(53.0% 0.1096 29.0)", "l54": "oklch(54.0% 0.1114 29.0)", "l55": "oklch(55.0% 0.1133 29.0)", "l56": "oklch(56.0% 0.1151 29.0)", "l57": "oklch(57.0% 0.1168 29.0)", "l58": "oklch(58.0% 0.1185 29.0)", "l59": "oklch(59.0% 0.1202 29.0)", "l60": "oklch(60.0% 0.1218 29.0)", "l61": "oklch(61.0% 0.1233 29.0)", "l62": "oklch(62.0% 0.1247 29.0)", "l63": "oklch(63.0% 0.1260 29.0)", "l64": "oklch(64.0% 0.1271 29.0)", "l65": "oklch(65.0% 0.1281 29.0)", "l66": "oklch(66.0% 0.1289 29.0)", "l67": "oklch(67.0% 0.1294 29.0)", "l68": "oklch(68.0% 0.1296 29.0)", "l69": "oklch(69.0% 0.1294 29.0)", "l70": "oklch(70.0% 0.1288 29.0)", "l71": "oklch(71.0% 0.1278 29.0)", "l72": "oklch(72.0% 0.1262 29.0)", "l73": "oklch(73.0% 0.1241 29.0)", "l74": "oklch(74.0% 0.1216 29.0)", "l75": "oklch(75.0% 0.1186 29.0)", "l76": "oklch(76.0% 0.1152 29.0)", "l77": "oklch(77.0% 0.1115 29.0)", "l78": "oklch(78.0% 0.1075 29.0)", "l79": "oklch(79.0% 0.1033 29.0)", "l80": "oklch(80.0% 0.0989 29.0)", "l81": "oklch(81.0% 0.0943 29.0)", "l82": "oklch(82.0% 0.0897 29.0)", "l83": "oklch(83.0% 0.0849 29.0)", "l84": "oklch(84.0% 0.0800 29.0)", "l85": "oklch(85.0% 0.0751 29.0)", "l86": "oklch(86.0% 0.0701 29.0)", "l87": "oklch(87.0% 0.0651 29.0)", "l88": "oklch(88.0% 0.0600 29.0)", "l89": "oklch(89.0% 0.0549 29.0)", "l90": "oklch(90.0% 0.0497 29.0)", "l91": "oklch(91.0% 0.0445 29.0)", "l92": "oklch(92.0% 0.0393 29.0)", "l93": "oklch(93.0% 0.0341 29.0)", "l94": "oklch(94.0% 0.0289 29.0)", "l95": "oklch(95.0% 0.0236 29.0)", "l96": "oklch(96.0% 0.0236 29.0)", "l97": "oklch(97.0% 0.0236 29.0)", "l98": "oklch(98.0% 0.0236 29.0)", "l99": "oklch(99.0% 0.0236 29.0)", "l100": "oklch(100.0% 0.0236 29.0)"}, "orange": {"l0": "oklch(0.0% 0.0315 62.5)", "l1": "oklch(1.0% 0.0315 62.5)", "l2": "oklch(2.0% 0.0315 62.5)", "l3": "oklch(3.0% 0.0315 62.5)", "l4": "oklch(4.0% 0.0315 62.5)", "l5": "oklch(5.0% 0.0315 62.5)", "l6": "oklch(6.0% 0.0315 62.5)", "l7": "oklch(7.0% 0.0315 62.5)", "l8": "oklch(8.0% 0.0315 62.5)", "l9": "oklch(9.0% 0.0315 62.5)", "l10": "oklch(10.0% 0.0315 62.5)", "l11": "oklch(11.0% 0.0315 62.5)", "l12": "oklch(12.0% 0.0315 62.5)", "l13": "oklch(13.0% 0.0315 62.5)", "l14": "oklch(14.0% 0.0315 62.5)", "l15": "oklch(15.0% 0.0315 62.5)", "l16": "oklch(16.0% 0.0336 62.5)", "l17": "oklch(17.0% 0.0357 62.5)", "l18": "oklch(18.0% 0.0378 62.5)", "l19": "oklch(19.0% 0.0400 62.5)", "l20": "oklch(20.0% 0.0421 62.5)", "l21": "oklch(21.0% 0.0442 62.5)", "l22": "oklch(22.0% 0.0463 62.5)", "l23": "oklch(23.0% 0.0484 62.5)", "l24": "oklch(24.0% 0.0505 62.5)", "l25": "oklch(25.0% 0.0526 62.5)", "l26": "oklch(26.0% 0.0547 62.5)", "l27": "oklch(27.0% 0.0568 62.5)", "l28": "oklch(28.0% 0.0589 62.5)", "l29": "oklch(29.0% 0.0610 62.5)", "l30": "oklch(30.0% 0.0631 62.5)", "l31": "oklch(31.0% 0.0652 62.5)", "l32": "oklch(32.0% 0.0672 62.5)", "l33": "oklch(33.0% 0.0693 62.5)", "l34": "oklch(34.0% 0.0714 62.5)", "l35": "oklch(35.0% 0.0735 62.5)", "l36": "oklch(36.0% 0.0755 62.5)", "l37": "oklch(37.0% 0.0776 62.5)", "l38": "oklch(38.0% 0.0797 62.5)", "l39": "oklch(39.0% 0.0817 62.5)", "l40": "oklch(40.0% 0.0838 62.5)", "l41": "oklch(41.0% 0.0858 62.5)", "l42": "oklch(42.0% 0.0879 62.5)", "l43": "oklch(43.0% 0.0899 62.5)", "l44": "oklch(44.0% 0.0919 62.5)", "l45": "oklch(45.0% 0.0939 62.5)", "l46": "oklch(46.0% 0.0959 62.5)", "l47": "oklch(47.0% 0.0979 62.5)", "l48": "oklch(48.0% 0.0999 62.5)", "l49": "oklch(49.0% 0.1019 62.5)", "l50": "oklch(50.0% 0.1038 62.5)", "l51": "oklch(51.0% 0.1058 62.5)", "l52": "oklch(52.0% 0.1077 62.5)", "l53": "oklch(53.0% 0.1096 62.5)", "l54": "oklch(54.0% 0.1114 62.5)", "l55": "oklch(55.0% 0.1133 62.5)", "l56": "oklch(56.0% 0.1151 62.5)", "l57": "oklch(57.0% 0.1168 62.5)", "l58": "oklch(58.0% 0.1185 62.5)", "l59": "oklch(59.0% 0.1202 62.5)", "l60": "oklch(60.0% 0.1218 62.5)", "l61": "oklch(61.0% 0.1233 62.5)", "l62": "oklch(62.0% 0.1247 62.5)", "l63": "oklch(63.0% 0.1260 62.5)", "l64": "oklch(64.0% 0.1271 62.5)", "l65": "oklch(65.0% 0.1281 62.5)", "l66": "oklch(66.0% 0.1289 62.5)", "l67": "oklch(67.0% 0.1294 62.5)", "l68": "oklch(68.0% 0.1296 62.5)", "l69": "oklch(69.0% 0.1294 62.5)", "l70": "oklch(70.0% 0.1288 62.5)", "l71": "oklch(71.0% 0.1278 62.5)", "l72": "oklch(72.0% 0.1262 62.5)", "l73": "oklch(73.0% 0.1241 62.5)", "l74": "oklch(74.0% 0.1216 62.5)", "l75": "oklch(75.0% 0.1186 62.5)", "l76": "oklch(76.0% 0.1152 62.5)", "l77": "oklch(77.0% 0.1115 62.5)", "l78": "oklch(78.0% 0.1075 62.5)", "l79": "oklch(79.0% 0.1033 62.5)", "l80": "oklch(80.0% 0.0989 62.5)", "l81": "oklch(81.0% 0.0943 62.5)", "l82": "oklch(82.0% 0.0897 62.5)", "l83": "oklch(83.0% 0.0849 62.5)", "l84": "oklch(84.0% 0.0800 62.5)", "l85": "oklch(85.0% 0.0751 62.5)", "l86": "oklch(86.0% 0.0701 62.5)", "l87": "oklch(87.0% 0.0651 62.5)", "l88": "oklch(88.0% 0.0600 62.5)", "l89": "oklch(89.0% 0.0549 62.5)", "l90": "oklch(90.0% 0.0497 62.5)", "l91": "oklch(91.0% 0.0445 62.5)", "l92": "oklch(92.0% 0.0393 62.5)", "l93": "oklch(93.0% 0.0341 62.5)", "l94": "oklch(94.0% 0.0289 62.5)", "l95": "oklch(95.0% 0.0236 62.5)", "l96": "oklch(96.0% 0.0236 62.5)", "l97": "oklch(97.0% 0.0236 62.5)", "l98": "oklch(98.0% 0.0236 62.5)", "l99": "oklch(99.0% 0.0236 62.5)", "l100": "oklch(100.0% 0.0236 62.5)"}, "yellow": {"l0": "oklch(0.0% 0.0315 104.0)", "l1": "oklch(1.0% 0.0315 104.0)", "l2": "oklch(2.0% 0.0315 104.0)", "l3": "oklch(3.0% 0.0315 104.0)", "l4": "oklch(4.0% 0.0315 104.0)", "l5": "oklch(5.0% 0.0315 104.0)", "l6": "oklch(6.0% 0.0315 104.0)", "l7": "oklch(7.0% 0.0315 104.0)", "l8": "oklch(8.0% 0.0315 104.0)", "l9": "oklch(9.0% 0.0315 104.0)", "l10": "oklch(10.0% 0.0315 104.0)", "l11": "oklch(11.0% 0.0315 104.0)", "l12": "oklch(12.0% 0.0315 104.0)", "l13": "oklch(13.0% 0.0315 104.0)", "l14": "oklch(14.0% 0.0315 104.0)", "l15": "oklch(15.0% 0.0315 104.0)", "l16": "oklch(16.0% 0.0336 104.0)", "l17": "oklch(17.0% 0.0357 104.0)", "l18": "oklch(18.0% 0.0378 104.0)", "l19": "oklch(19.0% 0.0400 104.0)", "l20": "oklch(20.0% 0.0421 104.0)", "l21": "oklch(21.0% 0.0442 104.0)", "l22": "oklch(22.0% 0.0463 104.0)", "l23": "oklch(23.0% 0.0484 104.0)", "l24": "oklch(24.0% 0.0505 104.0)", "l25": "oklch(25.0% 0.0526 104.0)", "l26": "oklch(26.0% 0.0547 104.0)", "l27": "oklch(27.0% 0.0568 104.0)", "l28": "oklch(28.0% 0.0589 104.0)", "l29": "oklch(29.0% 0.0610 104.0)", "l30": "oklch(30.0% 0.0631 104.0)", "l31": "oklch(31.0% 0.0652 104.0)", "l32": "oklch(32.0% 0.0672 104.0)", "l33": "oklch(33.0% 0.0693 104.0)", "l34": "oklch(34.0% 0.0714 104.0)", "l35": "oklch(35.0% 0.0735 104.0)", "l36": "oklch(36.0% 0.0755 104.0)", "l37": "oklch(37.0% 0.0776 104.0)", "l38": "oklch(38.0% 0.0797 104.0)", "l39": "oklch(39.0% 0.0817 104.0)", "l40": "oklch(40.0% 0.0838 104.0)", "l41": "oklch(41.0% 0.0858 104.0)", "l42": "oklch(42.0% 0.0879 104.0)", "l43": "oklch(43.0% 0.0899 104.0)", "l44": "oklch(44.0% 0.0919 104.0)", "l45": "oklch(45.0% 0.0939 104.0)", "l46": "oklch(46.0% 0.0959 104.0)", "l47": "oklch(47.0% 0.0979 104.0)", "l48": "oklch(48.0% 0.0999 104.0)", "l49": "oklch(49.0% 0.1019 104.0)", "l50": "oklch(50.0% 0.1038 104.0)", "l51": "oklch(51.0% 0.1058 104.0)", "l52": "oklch(52.0% 0.1077 104.0)", "l53": "oklch(53.0% 0.1096 104.0)", "l54": "oklch(54.0% 0.1114 104.0)", "l55": "oklch(55.0% 0.1133 104.0)", "l56": "oklch(56.0% 0.1151 104.0)", "l57": "oklch(57.0% 0.1168 104.0)", "l58": "oklch(58.0% 0.1185 104.0)", "l59": "oklch(59.0% 0.1202 104.0)", "l60": "oklch(60.0% 0.1218 104.0)", "l61": "oklch(61.0% 0.1233 104.0)", "l62": "oklch(62.0% 0.1247 104.0)", "l63": "oklch(63.0% 0.1260 104.0)", "l64": "oklch(64.0% 0.1271 104.0)", "l65": "oklch(65.0% 0.1281 104.0)", "l66": "oklch(66.0% 0.1289 104.0)", "l67": "oklch(67.0% 0.1294 104.0)", "l68": "oklch(68.0% 0.1296 104.0)", "l69": "oklch(69.0% 0.1294 104.0)", "l70": "oklch(70.0% 0.1288 104.0)", "l71": "oklch(71.0% 0.1278 104.0)", "l72": "oklch(72.0% 0.1262 104.0)", "l73": "oklch(73.0% 0.1241 104.0)", "l74": "oklch(74.0% 0.1216 104.0)", "l75": "oklch(75.0% 0.1186 104.0)", "l76": "oklch(76.0% 0.1152 104.0)", "l77": "oklch(77.0% 0.1115 104.0)", "l78": "oklch(78.0% 0.1075 104.0)", "l79": "oklch(79.0% 0.1033 104.0)", "l80": "oklch(80.0% 0.0989 104.0)", "l81": "oklch(81.0% 0.0943 104.0)", "l82": "oklch(82.0% 0.0897 104.0)", "l83": "oklch(83.0% 0.0849 104.0)", "l84": "oklch(84.0% 0.0800 104.0)", "l85": "oklch(85.0% 0.0751 104.0)", "l86": "oklch(86.0% 0.0701 104.0)", "l87": "oklch(87.0% 0.0651 104.0)", "l88": "oklch(88.0% 0.0600 104.0)", "l89": "oklch(89.0% 0.0549 104.0)", "l90": "oklch(90.0% 0.0497 104.0)", "l91": "oklch(91.0% 0.0445 104.0)", "l92": "oklch(92.0% 0.0393 104.0)", "l93": "oklch(93.0% 0.0341 104.0)", "l94": "oklch(94.0% 0.0289 104.0)", "l95": "oklch(95.0% 0.0236 104.0)", "l96": "oklch(96.0% 0.0236 104.0)", "l97": "oklch(97.0% 0.0236 104.0)", "l98": "oklch(98.0% 0.0236 104.0)", "l99": "oklch(99.0% 0.0236 104.0)", "l100": "oklch(100.0% 0.0236 104.0)"}, "green": {"l0": "oklch(0.0% 0.0315 148.0)", "l1": "oklch(1.0% 0.0315 148.0)", "l2": "oklch(2.0% 0.0315 148.0)", "l3": "oklch(3.0% 0.0315 148.0)", "l4": "oklch(4.0% 0.0315 148.0)", "l5": "oklch(5.0% 0.0315 148.0)", "l6": "oklch(6.0% 0.0315 148.0)", "l7": "oklch(7.0% 0.0315 148.0)", "l8": "oklch(8.0% 0.0315 148.0)", "l9": "oklch(9.0% 0.0315 148.0)", "l10": "oklch(10.0% 0.0315 148.0)", "l11": "oklch(11.0% 0.0315 148.0)", "l12": "oklch(12.0% 0.0315 148.0)", "l13": "oklch(13.0% 0.0315 148.0)", "l14": "oklch(14.0% 0.0315 148.0)", "l15": "oklch(15.0% 0.0315 148.0)", "l16": "oklch(16.0% 0.0336 148.0)", "l17": "oklch(17.0% 0.0357 148.0)", "l18": "oklch(18.0% 0.0378 148.0)", "l19": "oklch(19.0% 0.0400 148.0)", "l20": "oklch(20.0% 0.0421 148.0)", "l21": "oklch(21.0% 0.0442 148.0)", "l22": "oklch(22.0% 0.0463 148.0)", "l23": "oklch(23.0% 0.0484 148.0)", "l24": "oklch(24.0% 0.0505 148.0)", "l25": "oklch(25.0% 0.0526 148.0)", "l26": "oklch(26.0% 0.0547 148.0)", "l27": "oklch(27.0% 0.0568 148.0)", "l28": "oklch(28.0% 0.0589 148.0)", "l29": "oklch(29.0% 0.0610 148.0)", "l30": "oklch(30.0% 0.0631 148.0)", "l31": "oklch(31.0% 0.0652 148.0)", "l32": "oklch(32.0% 0.0672 148.0)", "l33": "oklch(33.0% 0.0693 148.0)", "l34": "oklch(34.0% 0.0714 148.0)", "l35": "oklch(35.0% 0.0735 148.0)", "l36": "oklch(36.0% 0.0755 148.0)", "l37": "oklch(37.0% 0.0776 148.0)", "l38": "oklch(38.0% 0.0797 148.0)", "l39": "oklch(39.0% 0.0817 148.0)", "l40": "oklch(40.0% 0.0838 148.0)", "l41": "oklch(41.0% 0.0858 148.0)", "l42": "oklch(42.0% 0.0879 148.0)", "l43": "oklch(43.0% 0.0899 148.0)", "l44": "oklch(44.0% 0.0919 148.0)", "l45": "oklch(45.0% 0.0939 148.0)", "l46": "oklch(46.0% 0.0959 148.0)", "l47": "oklch(47.0% 0.0979 148.0)", "l48": "oklch(48.0% 0.0999 148.0)", "l49": "oklch(49.0% 0.1019 148.0)", "l50": "oklch(50.0% 0.1038 148.0)", "l51": "oklch(51.0% 0.1058 148.0)", "l52": "oklch(52.0% 0.1077 148.0)", "l53": "oklch(53.0% 0.1096 148.0)", "l54": "oklch(54.0% 0.1114 148.0)", "l55": "oklch(55.0% 0.1133 148.0)", "l56": "oklch(56.0% 0.1151 148.0)", "l57": "oklch(57.0% 0.1168 148.0)", "l58": "oklch(58.0% 0.1185 148.0)", "l59": "oklch(59.0% 0.1202 148.0)", "l60": "oklch(60.0% 0.1218 148.0)", "l61": "oklch(61.0% 0.1233 148.0)", "l62": "oklch(62.0% 0.1247 148.0)", "l63": "oklch(63.0% 0.1260 148.0)", "l64": "oklch(64.0% 0.1271 148.0)", "l65": "oklch(65.0% 0.1281 148.0)", "l66": "oklch(66.0% 0.1289 148.0)", "l67": "oklch(67.0% 0.1294 148.0)", "l68": "oklch(68.0% 0.1296 148.0)", "l69": "oklch(69.0% 0.1294 148.0)", "l70": "oklch(70.0% 0.1288 148.0)", "l71": "oklch(71.0% 0.1278 148.0)", "l72": "oklch(72.0% 0.1262 148.0)", "l73": "oklch(73.0% 0.1241 148.0)", "l74": "oklch(74.0% 0.1216 148.0)", "l75": "oklch(75.0% 0.1186 148.0)", "l76": "oklch(76.0% 0.1152 148.0)", "l77": "oklch(77.0% 0.1115 148.0)", "l78": "oklch(78.0% 0.1075 148.0)", "l79": "oklch(79.0% 0.1033 148.0)", "l80": "oklch(80.0% 0.0989 148.0)", "l81": "oklch(81.0% 0.0943 148.0)", "l82": "oklch(82.0% 0.0897 148.0)", "l83": "oklch(83.0% 0.0849 148.0)", "l84": "oklch(84.0% 0.0800 148.0)", "l85": "oklch(85.0% 0.0751 148.0)", "l86": "oklch(86.0% 0.0701 148.0)", "l87": "oklch(87.0% 0.0651 148.0)", "l88": "oklch(88.0% 0.0600 148.0)", "l89": "oklch(89.0% 0.0549 148.0)", "l90": "oklch(90.0% 0.0497 148.0)", "l91": "oklch(91.0% 0.0445 148.0)", "l92": "oklch(92.0% 0.0393 148.0)", "l93": "oklch(93.0% 0.0341 148.0)", "l94": "oklch(94.0% 0.0289 148.0)", "l95": "oklch(95.0% 0.0236 148.0)", "l96": "oklch(96.0% 0.0236 148.0)", "l97": "oklch(97.0% 0.0236 148.0)", "l98": "oklch(98.0% 0.0236 148.0)", "l99": "oklch(99.0% 0.0236 148.0)", "l100": "oklch(100.0% 0.0236 148.0)"}, "blue": {"l0": "oklch(0.0% 0.0315 262.0)", "l1": "oklch(1.0% 0.0315 262.0)", "l2": "oklch(2.0% 0.0315 262.0)", "l3": "oklch(3.0% 0.0315 262.0)", "l4": "oklch(4.0% 0.0315 262.0)", "l5": "oklch(5.0% 0.0315 262.0)", "l6": "oklch(6.0% 0.0315 262.0)", "l7": "oklch(7.0% 0.0315 262.0)", "l8": "oklch(8.0% 0.0315 262.0)", "l9": "oklch(9.0% 0.0315 262.0)", "l10": "oklch(10.0% 0.0315 262.0)", "l11": "oklch(11.0% 0.0315 262.0)", "l12": "oklch(12.0% 0.0315 262.0)", "l13": "oklch(13.0% 0.0315 262.0)", "l14": "oklch(14.0% 0.0315 262.0)", "l15": "oklch(15.0% 0.0315 262.0)", "l16": "oklch(16.0% 0.0336 262.0)", "l17": "oklch(17.0% 0.0357 262.0)", "l18": "oklch(18.0% 0.0378 262.0)", "l19": "oklch(19.0% 0.0400 262.0)", "l20": "oklch(20.0% 0.0421 262.0)", "l21": "oklch(21.0% 0.0442 262.0)", "l22": "oklch(22.0% 0.0463 262.0)", "l23": "oklch(23.0% 0.0484 262.0)", "l24": "oklch(24.0% 0.0505 262.0)", "l25": "oklch(25.0% 0.0526 262.0)", "l26": "oklch(26.0% 0.0547 262.0)", "l27": "oklch(27.0% 0.0568 262.0)", "l28": "oklch(28.0% 0.0589 262.0)", "l29": "oklch(29.0% 0.0610 262.0)", "l30": "oklch(30.0% 0.0631 262.0)", "l31": "oklch(31.0% 0.0652 262.0)", "l32": "oklch(32.0% 0.0672 262.0)", "l33": "oklch(33.0% 0.0693 262.0)", "l34": "oklch(34.0% 0.0714 262.0)", "l35": "oklch(35.0% 0.0735 262.0)", "l36": "oklch(36.0% 0.0755 262.0)", "l37": "oklch(37.0% 0.0776 262.0)", "l38": "oklch(38.0% 0.0797 262.0)", "l39": "oklch(39.0% 0.0817 262.0)", "l40": "oklch(40.0% 0.0838 262.0)", "l41": "oklch(41.0% 0.0858 262.0)", "l42": "oklch(42.0% 0.0879 262.0)", "l43": "oklch(43.0% 0.0899 262.0)", "l44": "oklch(44.0% 0.0919 262.0)", "l45": "oklch(45.0% 0.0939 262.0)", "l46": "oklch(46.0% 0.0959 262.0)", "l47": "oklch(47.0% 0.0979 262.0)", "l48": "oklch(48.0% 0.0999 262.0)", "l49": "oklch(49.0% 0.1019 262.0)", "l50": "oklch(50.0% 0.1038 262.0)", "l51": "oklch(51.0% 0.1058 262.0)", "l52": "oklch(52.0% 0.1077 262.0)", "l53": "oklch(53.0% 0.1096 262.0)", "l54": "oklch(54.0% 0.1114 262.0)", "l55": "oklch(55.0% 0.1133 262.0)", "l56": "oklch(56.0% 0.1151 262.0)", "l57": "oklch(57.0% 0.1168 262.0)", "l58": "oklch(58.0% 0.1185 262.0)", "l59": "oklch(59.0% 0.1202 262.0)", "l60": "oklch(60.0% 0.1218 262.0)", "l61": "oklch(61.0% 0.1233 262.0)", "l62": "oklch(62.0% 0.1247 262.0)", "l63": "oklch(63.0% 0.1260 262.0)", "l64": "oklch(64.0% 0.1271 262.0)", "l65": "oklch(65.0% 0.1281 262.0)", "l66": "oklch(66.0% 0.1289 262.0)", "l67": "oklch(67.0% 0.1294 262.0)", "l68": "oklch(68.0% 0.1296 262.0)", "l69": "oklch(69.0% 0.1294 262.0)", "l70": "oklch(70.0% 0.1288 262.0)", "l71": "oklch(71.0% 0.1278 262.0)", "l72": "oklch(72.0% 0.1262 262.0)", "l73": "oklch(73.0% 0.1241 262.0)", "l74": "oklch(74.0% 0.1216 262.0)", "l75": "oklch(75.0% 0.1186 262.0)", "l76": "oklch(76.0% 0.1152 262.0)", "l77": "oklch(77.0% 0.1115 262.0)", "l78": "oklch(78.0% 0.1075 262.0)", "l79": "oklch(79.0% 0.1033 262.0)", "l80": "oklch(80.0% 0.0989 262.0)", "l81": "oklch(81.0% 0.0943 262.0)", "l82": "oklch(82.0% 0.0897 262.0)", "l83": "oklch(83.0% 0.0849 262.0)", "l84": "oklch(84.0% 0.0800 262.0)", "l85": "oklch(85.0% 0.0751 262.0)", "l86": "oklch(86.0% 0.0701 262.0)", "l87": "oklch(87.0% 0.0651 262.0)", "l88": "oklch(88.0% 0.0600 262.0)", "l89": "oklch(89.0% 0.0549 262.0)", "l90": "oklch(90.0% 0.0497 262.0)", "l91": "oklch(91.0% 0.0445 262.0)", "l92": "oklch(92.0% 0.0393 262.0)", "l93": "oklch(93.0% 0.0341 262.0)", "l94": "oklch(94.0% 0.0289 262.0)", "l95": "oklch(95.0% 0.0236 262.0)", "l96": "oklch(96.0% 0.0236 262.0)", "l97": "oklch(97.0% 0.0236 262.0)", "l98": "oklch(98.0% 0.0236 262.0)", "l99": "oklch(99.0% 0.0236 262.0)", "l100": "oklch(100.0% 0.0236 262.0)"}} \ No newline at end of file diff --git a/notebooks/palettes/monobiome-vUCC.toml b/notebooks/palettes/monobiome-vUCC.toml new file mode 100644 index 0000000..916bb0d --- /dev/null +++ b/notebooks/palettes/monobiome-vUCC.toml @@ -0,0 +1,1132 @@ +[alpine] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000000" +l6 = "#010101" +l7 = "#010101" +l8 = "#020202" +l9 = "#020202" +l10 = "#030303" +l11 = "#040404" +l12 = "#060606" +l13 = "#070707" +l14 = "#090909" +l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" +l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" +l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" +l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" +l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" +l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" +l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" +l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" +l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" +l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" +l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" +l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" +l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" +l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" +l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" +l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" +l95 = "#eeeeee" +l96 = "#f2f2f2" +l97 = "#f5f5f5" +l98 = "#f8f8f8" +l99 = "#fcfcfc" +l100 = "#ffffff" + +[badlands] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#010000" +l5 = "#010000" +l6 = "#020000" +l7 = "#020101" +l8 = "#030101" +l9 = "#040202" +l10 = "#060302" +l11 = "#070303" +l12 = "#090504" +l13 = "#0b0605" +l14 = "#0d0807" +l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" +l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" +l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" +l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" +l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" +l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" +l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" +l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" +l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" +l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" +l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" +l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" +l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" +l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" +l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" +l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" +l95 = "#f6ecea" +l96 = "#f9efee" +l97 = "#fcf3f1" +l98 = "#fff6f4" +l99 = "#fff9f8" +l100 = "#fffdfc" + +[chaparral] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#010000" +l5 = "#010000" +l6 = "#010100" +l7 = "#020100" +l8 = "#030101" +l9 = "#040201" +l10 = "#050301" +l11 = "#070402" +l12 = "#080503" +l13 = "#0a0704" +l14 = "#0c0805" +l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" +l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" +l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" +l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" +l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" +l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" +l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" +l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" +l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" +l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" +l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" +l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" +l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" +l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" +l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" +l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" +l95 = "#f4ede7" +l96 = "#f7f0ea" +l97 = "#fbf4ee" +l98 = "#fef7f1" +l99 = "#fffaf4" +l100 = "#fffefa" + +[savanna] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#010000" +l6 = "#010100" +l7 = "#010100" +l8 = "#020200" +l9 = "#030301" +l10 = "#040301" +l11 = "#050502" +l12 = "#060603" +l13 = "#080704" +l14 = "#0a0905" +l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" +l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" +l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" +l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" +l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" +l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" +l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" +l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" +l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" +l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" +l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" +l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" +l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" +l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" +l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" +l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" +l95 = "#efefe7" +l96 = "#f3f2ea" +l97 = "#f6f6ed" +l98 = "#f9f9f1" +l99 = "#fdfcf4" +l100 = "#ffffff" + +[grassland] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000100" +l6 = "#000100" +l7 = "#000101" +l8 = "#010201" +l9 = "#010302" +l10 = "#020402" +l11 = "#030503" +l12 = "#040704" +l13 = "#050805" +l14 = "#060a07" +l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" +l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" +l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" +l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" +l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" +l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" +l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" +l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" +l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" +l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" +l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" +l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" +l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" +l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" +l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" +l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" +l95 = "#eaf1ea" +l96 = "#edf4ee" +l97 = "#f0f7f1" +l98 = "#f4fbf4" +l99 = "#f7fef8" +l100 = "#ffffff" + +[tundra] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000001" +l5 = "#000001" +l6 = "#000102" +l7 = "#010103" +l8 = "#010203" +l9 = "#020205" +l10 = "#020306" +l11 = "#030408" +l12 = "#040609" +l13 = "#05070c" +l14 = "#07090e" +l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" +l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" +l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" +l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" +l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" +l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" +l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" +l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" +l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" +l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" +l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" +l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" +l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" +l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" +l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" +l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" +l95 = "#eaeff6" +l96 = "#eef2f9" +l97 = "#f1f5fd" +l98 = "#f4f9ff" +l99 = "#f8fcff" +l100 = "#ffffff" + +[red] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#010000" +l4 = "#020000" +l5 = "#030000" +l6 = "#040000" +l7 = "#050000" +l8 = "#070000" +l9 = "#080000" +l10 = "#0b0101" +l11 = "#0d0201" +l12 = "#0f0202" +l13 = "#120302" +l14 = "#140503" +l15 = "#160604" +l16 = "#190705" +l17 = "#1d0906" +l18 = "#200a08" +l19 = "#230c09" +l20 = "#260e0b" +l21 = "#290f0c" +l22 = "#2d110e" +l23 = "#30130f" +l24 = "#331511" +l25 = "#371712" +l26 = "#3a1814" +l27 = "#3e1a16" +l28 = "#411c17" +l29 = "#451e19" +l30 = "#49201b" +l31 = "#4c221c" +l32 = "#50241e" +l33 = "#532620" +l34 = "#572822" +l35 = "#5b2a23" +l36 = "#5f2c25" +l37 = "#622e27" +l38 = "#663029" +l39 = "#6a322b" +l40 = "#6e342d" +l41 = "#72362e" +l42 = "#763830" +l43 = "#7a3a32" +l44 = "#7d3d34" +l45 = "#813f36" +l46 = "#854138" +l47 = "#89433a" +l48 = "#8d453c" +l49 = "#91473e" +l50 = "#954a40" +l51 = "#994c42" +l52 = "#9d4e44" +l53 = "#a15046" +l54 = "#a65348" +l55 = "#aa554a" +l56 = "#ae574c" +l57 = "#b25a4e" +l58 = "#b65c50" +l59 = "#ba5f52" +l60 = "#be6155" +l61 = "#c26457" +l62 = "#c66659" +l63 = "#ca695c" +l64 = "#ce6b5e" +l65 = "#d26e61" +l66 = "#d57163" +l67 = "#d97466" +l68 = "#dd7769" +l69 = "#e07a6c" +l70 = "#e37d6f" +l71 = "#e68172" +l72 = "#e98476" +l73 = "#eb887a" +l74 = "#ee8c7e" +l75 = "#f09082" +l76 = "#f19486" +l77 = "#f3988b" +l78 = "#f49d90" +l79 = "#f6a194" +l80 = "#f7a599" +l81 = "#f8aa9e" +l82 = "#f9aea3" +l83 = "#fab3a8" +l84 = "#fbb7ad" +l85 = "#fbbcb2" +l86 = "#fcc0b7" +l87 = "#fcc5bc" +l88 = "#fdc9c1" +l89 = "#fdcec6" +l90 = "#fed2cb" +l91 = "#fed7d1" +l92 = "#fedbd6" +l93 = "#fee0db" +l94 = "#fee4e0" +l95 = "#fee9e5" +l96 = "#ffece9" +l97 = "#fff0ec" +l98 = "#fff4f2" +l99 = "#fff9f7" +l100 = "#fffdfc" + +[orange] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#010000" +l4 = "#010000" +l5 = "#020000" +l6 = "#030000" +l7 = "#040000" +l8 = "#060100" +l9 = "#070100" +l10 = "#090200" +l11 = "#0b0200" +l12 = "#0e0300" +l13 = "#100500" +l14 = "#120600" +l15 = "#140801" +l16 = "#170901" +l17 = "#1a0b01" +l18 = "#1d0d01" +l19 = "#200f01" +l20 = "#231102" +l21 = "#261302" +l22 = "#291502" +l23 = "#2d1702" +l24 = "#301903" +l25 = "#331b03" +l26 = "#361d03" +l27 = "#3a1f04" +l28 = "#3d2104" +l29 = "#402305" +l30 = "#442605" +l31 = "#472806" +l32 = "#4b2a06" +l33 = "#4e2c07" +l34 = "#522e08" +l35 = "#553108" +l36 = "#593309" +l37 = "#5c350a" +l38 = "#60370b" +l39 = "#633a0c" +l40 = "#673c0d" +l41 = "#6b3e0e" +l42 = "#6e410f" +l43 = "#724310" +l44 = "#764510" +l45 = "#794811" +l46 = "#7d4a12" +l47 = "#814d13" +l48 = "#854f15" +l49 = "#885116" +l50 = "#8c5417" +l51 = "#905618" +l52 = "#945919" +l53 = "#985b1a" +l54 = "#9c5e1b" +l55 = "#9f611d" +l56 = "#a3631e" +l57 = "#a76620" +l58 = "#ab6821" +l59 = "#af6b23" +l60 = "#b36e24" +l61 = "#b77026" +l62 = "#ba7328" +l63 = "#be762a" +l64 = "#c2792c" +l65 = "#c67b2f" +l66 = "#c97e31" +l67 = "#cd8134" +l68 = "#d08438" +l69 = "#d3873b" +l70 = "#d68b3f" +l71 = "#d98e44" +l72 = "#dc9149" +l73 = "#df954e" +l74 = "#e19954" +l75 = "#e39c5a" +l76 = "#e5a060" +l77 = "#e7a466" +l78 = "#e9a86d" +l79 = "#eaac73" +l80 = "#ecb07a" +l81 = "#edb481" +l82 = "#eeb887" +l83 = "#f0bc8e" +l84 = "#f1c095" +l85 = "#f2c49b" +l86 = "#f3c8a2" +l87 = "#f4cca9" +l88 = "#f5d0af" +l89 = "#f6d4b6" +l90 = "#f7d8bd" +l91 = "#f8dcc4" +l92 = "#f8dfca" +l93 = "#f9e3d1" +l94 = "#fae7d8" +l95 = "#fbebdf" +l96 = "#feefe2" +l97 = "#fff2e5" +l98 = "#fff6ea" +l99 = "#fffaf2" +l100 = "#fffefa" + +[yellow] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#010000" +l6 = "#010100" +l7 = "#020100" +l8 = "#030200" +l9 = "#030200" +l10 = "#050300" +l11 = "#060500" +l12 = "#070600" +l13 = "#090800" +l14 = "#0b0900" +l15 = "#0d0c00" +l16 = "#100e00" +l17 = "#121000" +l18 = "#141200" +l19 = "#171400" +l20 = "#191700" +l21 = "#1c1900" +l22 = "#1e1b00" +l23 = "#211e00" +l24 = "#232000" +l25 = "#262300" +l26 = "#292500" +l27 = "#2b2700" +l28 = "#2e2a00" +l29 = "#312c00" +l30 = "#332f00" +l31 = "#363100" +l32 = "#393400" +l33 = "#3c3700" +l34 = "#3e3901" +l35 = "#413c01" +l36 = "#443f01" +l37 = "#474101" +l38 = "#4a4401" +l39 = "#4d4701" +l40 = "#4f4901" +l41 = "#524c01" +l42 = "#554f02" +l43 = "#585202" +l44 = "#5b5402" +l45 = "#5e5702" +l46 = "#615a03" +l47 = "#645d03" +l48 = "#676004" +l49 = "#6a6304" +l50 = "#6d6505" +l51 = "#716806" +l52 = "#746b07" +l53 = "#776e07" +l54 = "#7a7109" +l55 = "#7d740a" +l56 = "#80770b" +l57 = "#837a0d" +l58 = "#867d0e" +l59 = "#8a8010" +l60 = "#8d8312" +l61 = "#908614" +l62 = "#938916" +l63 = "#968c19" +l64 = "#998f1c" +l65 = "#9d921f" +l66 = "#a09522" +l67 = "#a39825" +l68 = "#a69c29" +l69 = "#a99f2e" +l70 = "#aca233" +l71 = "#afa538" +l72 = "#b2a83e" +l73 = "#b5ab44" +l74 = "#b8ae4b" +l75 = "#bab251" +l76 = "#bdb558" +l77 = "#c0b85f" +l78 = "#c3bb66" +l79 = "#c5be6d" +l80 = "#c8c174" +l81 = "#cbc47b" +l82 = "#cdc782" +l83 = "#d0cb89" +l84 = "#d3ce90" +l85 = "#d5d198" +l86 = "#d8d49f" +l87 = "#dbd7a6" +l88 = "#dedaad" +l89 = "#e0ddb4" +l90 = "#e3e0bb" +l91 = "#e6e3c2" +l92 = "#e8e6c9" +l93 = "#ebe9d0" +l94 = "#eeedd7" +l95 = "#f1f0de" +l96 = "#f4f3e1" +l97 = "#f7f6e4" +l98 = "#fbfae8" +l99 = "#fefdeb" +l100 = "#ffffff" + +[green] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000000" +l4 = "#000000" +l5 = "#000100" +l6 = "#000100" +l7 = "#000200" +l8 = "#000300" +l9 = "#000400" +l10 = "#000501" +l11 = "#000701" +l12 = "#000802" +l13 = "#010a02" +l14 = "#020c03" +l15 = "#030f04" +l16 = "#041105" +l17 = "#041406" +l18 = "#051608" +l19 = "#061909" +l20 = "#071b0b" +l21 = "#081e0c" +l22 = "#09200e" +l23 = "#0a230f" +l24 = "#0c2611" +l25 = "#0d2812" +l26 = "#0e2b14" +l27 = "#102e16" +l28 = "#113117" +l29 = "#133319" +l30 = "#14361b" +l31 = "#16391c" +l32 = "#173c1e" +l33 = "#183f20" +l34 = "#1a4222" +l35 = "#1b4523" +l36 = "#1d4825" +l37 = "#1e4b27" +l38 = "#204e29" +l39 = "#21512b" +l40 = "#23542d" +l41 = "#25572e" +l42 = "#265a30" +l43 = "#285d32" +l44 = "#296034" +l45 = "#2b6336" +l46 = "#2d6638" +l47 = "#2e693a" +l48 = "#306d3c" +l49 = "#32703e" +l50 = "#337340" +l51 = "#357642" +l52 = "#377944" +l53 = "#397d46" +l54 = "#3b8048" +l55 = "#3c834a" +l56 = "#3e874c" +l57 = "#408a4e" +l58 = "#428d50" +l59 = "#449053" +l60 = "#469455" +l61 = "#489757" +l62 = "#4b9a59" +l63 = "#4d9e5c" +l64 = "#4fa15e" +l65 = "#52a461" +l66 = "#54a763" +l67 = "#57ab66" +l68 = "#5aae69" +l69 = "#5eb16c" +l70 = "#61b46f" +l71 = "#65b773" +l72 = "#69ba76" +l73 = "#6dbd7a" +l74 = "#72c07e" +l75 = "#77c383" +l76 = "#7cc587" +l77 = "#81c88c" +l78 = "#87cb90" +l79 = "#8ccd95" +l80 = "#91d09a" +l81 = "#97d29f" +l82 = "#9cd5a3" +l83 = "#a2d7a8" +l84 = "#a7d9ad" +l85 = "#addcb2" +l86 = "#b3deb7" +l87 = "#b8e1bd" +l88 = "#bee3c2" +l89 = "#c3e5c7" +l90 = "#c9e8cc" +l91 = "#ceead1" +l92 = "#d4ecd6" +l93 = "#d9efdb" +l94 = "#dff1e1" +l95 = "#e4f3e6" +l96 = "#e8f6e9" +l97 = "#ebfaec" +l98 = "#eefdf0" +l99 = "#f2fff3" +l100 = "#ffffff" + +[blue] +l0 = "#000000" +l1 = "#000000" +l2 = "#000000" +l3 = "#000002" +l4 = "#000003" +l5 = "#000004" +l6 = "#000005" +l7 = "#000107" +l8 = "#000109" +l9 = "#00020b" +l10 = "#01030d" +l11 = "#01040f" +l12 = "#020511" +l13 = "#030714" +l14 = "#040916" +l15 = "#050b18" +l16 = "#060d1c" +l17 = "#070f1f" +l18 = "#081122" +l19 = "#0a1326" +l20 = "#0b1629" +l21 = "#0d182c" +l22 = "#0e1a30" +l23 = "#101c33" +l24 = "#121f37" +l25 = "#13213b" +l26 = "#15233e" +l27 = "#172642" +l28 = "#182846" +l29 = "#1a2b49" +l30 = "#1c2d4d" +l31 = "#1e3051" +l32 = "#1f3255" +l33 = "#213559" +l34 = "#23375d" +l35 = "#253a61" +l36 = "#273c65" +l37 = "#283f69" +l38 = "#2a416d" +l39 = "#2c4471" +l40 = "#2e4775" +l41 = "#304979" +l42 = "#324c7d" +l43 = "#344f81" +l44 = "#365185" +l45 = "#385489" +l46 = "#3a578d" +l47 = "#3c5a92" +l48 = "#3e5c96" +l49 = "#405f9a" +l50 = "#42629e" +l51 = "#4465a2" +l52 = "#4668a7" +l53 = "#486aab" +l54 = "#4a6daf" +l55 = "#4c70b3" +l56 = "#4e73b8" +l57 = "#5076bc" +l58 = "#5379c0" +l59 = "#557cc4" +l60 = "#577fc9" +l61 = "#5982cd" +l62 = "#5c85d1" +l63 = "#5e88d5" +l64 = "#618bd9" +l65 = "#638edd" +l66 = "#6691e1" +l67 = "#6994e4" +l68 = "#6b97e8" +l69 = "#6e9aeb" +l70 = "#729dee" +l71 = "#75a1f1" +l72 = "#79a4f4" +l73 = "#7ca7f6" +l74 = "#80aaf8" +l75 = "#84aef9" +l76 = "#89b1fa" +l77 = "#8db4fc" +l78 = "#92b8fd" +l79 = "#96bbfd" +l80 = "#9bbefe" +l81 = "#a0c1ff" +l82 = "#a5c5ff" +l83 = "#a9c8ff" +l84 = "#aecbff" +l85 = "#b3cfff" +l86 = "#b8d2ff" +l87 = "#bdd5ff" +l88 = "#c2d8ff" +l89 = "#c7dcff" +l90 = "#ccdfff" +l91 = "#d1e2ff" +l92 = "#d7e5ff" +l93 = "#dce9ff" +l94 = "#e1ecff" +l95 = "#e6efff" +l96 = "#e9f2ff" +l97 = "#eef6ff" +l98 = "#f3f9ff" +l99 = "#f8fcff" +l100 = "#ffffff" diff --git a/templates/groups/monobiome-oklch.json b/templates/groups/monobiome-oklch.json index d9d1974..98a118a 100644 --- a/templates/groups/monobiome-oklch.json +++ b/templates/groups/monobiome-oklch.json @@ -1,222 +1,1003 @@ { - "default": { - "l15": "oklch(15% 0 137.33)", - "l20": "oklch(20% 0 137.33)", - "l25": "oklch(25% 0 137.33)", - "l30": "oklch(30% 0 137.33)", - "l35": "oklch(35% 0 137.33)", - "l40": "oklch(40% 0 137.33)", - "l45": "oklch(45% 0 137.33)", - "l50": "oklch(50% 0 137.33)", - "l55": "oklch(55% 0 137.33)", - "l60": "oklch(60% 0 137.33)", - "l65": "oklch(65% 0 137.33)", - "l70": "oklch(70% 0 137.33)", - "l75": "oklch(75% 0 137.33)", - "l80": "oklch(80% 0 137.33)", - "l85": "oklch(85% 0 137.33)", - "l90": "oklch(90% 0 137.33)", - "l95": "oklch(95% 0 137.33)", - "l98": "oklch(97.5% 0 137.33)" + "alpine": { + "10": "oklch(10.0% 0.0000 0.0)", + "11": "oklch(11.0% 0.0000 0.0)", + "12": "oklch(12.0% 0.0000 0.0)", + "13": "oklch(13.0% 0.0000 0.0)", + "14": "oklch(14.0% 0.0000 0.0)", + "15": "oklch(15.0% 0.0000 0.0)", + "16": "oklch(16.0% 0.0000 0.0)", + "17": "oklch(17.0% 0.0000 0.0)", + "18": "oklch(18.0% 0.0000 0.0)", + "19": "oklch(19.0% 0.0000 0.0)", + "20": "oklch(20.0% 0.0000 0.0)", + "21": "oklch(21.0% 0.0000 0.0)", + "22": "oklch(22.0% 0.0000 0.0)", + "23": "oklch(23.0% 0.0000 0.0)", + "24": "oklch(24.0% 0.0000 0.0)", + "25": "oklch(25.0% 0.0000 0.0)", + "26": "oklch(26.0% 0.0000 0.0)", + "27": "oklch(27.0% 0.0000 0.0)", + "28": "oklch(28.0% 0.0000 0.0)", + "29": "oklch(29.0% 0.0000 0.0)", + "30": "oklch(30.0% 0.0000 0.0)", + "31": "oklch(31.0% 0.0000 0.0)", + "32": "oklch(32.0% 0.0000 0.0)", + "33": "oklch(33.0% 0.0000 0.0)", + "34": "oklch(34.0% 0.0000 0.0)", + "35": "oklch(35.0% 0.0000 0.0)", + "36": "oklch(36.0% 0.0000 0.0)", + "37": "oklch(37.0% 0.0000 0.0)", + "38": "oklch(38.0% 0.0000 0.0)", + "39": "oklch(39.0% 0.0000 0.0)", + "40": "oklch(40.0% 0.0000 0.0)", + "41": "oklch(41.0% 0.0000 0.0)", + "42": "oklch(42.0% 0.0000 0.0)", + "43": "oklch(43.0% 0.0000 0.0)", + "44": "oklch(44.0% 0.0000 0.0)", + "45": "oklch(45.0% 0.0000 0.0)", + "46": "oklch(46.0% 0.0000 0.0)", + "47": "oklch(47.0% 0.0000 0.0)", + "48": "oklch(48.0% 0.0000 0.0)", + "49": "oklch(49.0% 0.0000 0.0)", + "50": "oklch(50.0% 0.0000 0.0)", + "51": "oklch(51.0% 0.0000 0.0)", + "52": "oklch(52.0% 0.0000 0.0)", + "53": "oklch(53.0% 0.0000 0.0)", + "54": "oklch(54.0% 0.0000 0.0)", + "55": "oklch(55.0% 0.0000 0.0)", + "56": "oklch(56.0% 0.0000 0.0)", + "57": "oklch(57.0% 0.0000 0.0)", + "58": "oklch(58.0% 0.0000 0.0)", + "59": "oklch(59.0% 0.0000 0.0)", + "60": "oklch(60.0% 0.0000 0.0)", + "61": "oklch(61.0% 0.0000 0.0)", + "62": "oklch(62.0% 0.0000 0.0)", + "63": "oklch(63.0% 0.0000 0.0)", + "64": "oklch(64.0% 0.0000 0.0)", + "65": "oklch(65.0% 0.0000 0.0)", + "66": "oklch(66.0% 0.0000 0.0)", + "67": "oklch(67.0% 0.0000 0.0)", + "68": "oklch(68.0% 0.0000 0.0)", + "69": "oklch(69.0% 0.0000 0.0)", + "70": "oklch(70.0% 0.0000 0.0)", + "71": "oklch(71.0% 0.0000 0.0)", + "72": "oklch(72.0% 0.0000 0.0)", + "73": "oklch(73.0% 0.0000 0.0)", + "74": "oklch(74.0% 0.0000 0.0)", + "75": "oklch(75.0% 0.0000 0.0)", + "76": "oklch(76.0% 0.0000 0.0)", + "77": "oklch(77.0% 0.0000 0.0)", + "78": "oklch(78.0% 0.0000 0.0)", + "79": "oklch(79.0% 0.0000 0.0)", + "80": "oklch(80.0% 0.0000 0.0)", + "81": "oklch(81.0% 0.0000 0.0)", + "82": "oklch(82.0% 0.0000 0.0)", + "83": "oklch(83.0% 0.0000 0.0)", + "84": "oklch(84.0% 0.0000 0.0)", + "85": "oklch(85.0% 0.0000 0.0)", + "86": "oklch(86.0% 0.0000 0.0)", + "87": "oklch(87.0% 0.0000 0.0)", + "88": "oklch(88.0% 0.0000 0.0)", + "89": "oklch(89.0% 0.0000 0.0)", + "90": "oklch(90.0% 0.0000 0.0)", + "91": "oklch(91.0% 0.0000 0.0)", + "92": "oklch(92.0% 0.0000 0.0)", + "93": "oklch(93.0% 0.0000 0.0)", + "94": "oklch(94.0% 0.0000 0.0)", + "95": "oklch(95.0% 0.0000 0.0)", + "96": "oklch(96.0% 0.0000 0.0)", + "97": "oklch(97.0% 0.0000 0.0)", + "98": "oklch(98.0% 0.0000 0.0)" }, "badlands": { - "l15": "oklch(15% 0.011 29)", - "l20": "oklch(20% 0.011 29)", - "l25": "oklch(25% 0.011 29)", - "l30": "oklch(30% 0.011 29)", - "l35": "oklch(35% 0.011 29)", - "l40": "oklch(40% 0.011 29)", - "l45": "oklch(45% 0.011 29)", - "l50": "oklch(50% 0.011 29)", - "l55": "oklch(55% 0.011 29)", - "l60": "oklch(60% 0.011 29)", - "l65": "oklch(65% 0.011 29)", - "l70": "oklch(70% 0.011 29)", - "l75": "oklch(75% 0.011 29)", - "l80": "oklch(80% 0.011 29)", - "l85": "oklch(85% 0.011 29)", - "l90": "oklch(90% 0.011 29)", - "l95": "oklch(95% 0.011 29)", - "l98": "oklch(97.5% 0.011 29)" + "10": "oklch(10.0% 0.0110 29.0)", + "11": "oklch(11.0% 0.0110 29.0)", + "12": "oklch(12.0% 0.0110 29.0)", + "13": "oklch(13.0% 0.0110 29.0)", + "14": "oklch(14.0% 0.0110 29.0)", + "15": "oklch(15.0% 0.0110 29.0)", + "16": "oklch(16.0% 0.0110 29.0)", + "17": "oklch(17.0% 0.0110 29.0)", + "18": "oklch(18.0% 0.0110 29.0)", + "19": "oklch(19.0% 0.0110 29.0)", + "20": "oklch(20.0% 0.0110 29.0)", + "21": "oklch(21.0% 0.0110 29.0)", + "22": "oklch(22.0% 0.0110 29.0)", + "23": "oklch(23.0% 0.0110 29.0)", + "24": "oklch(24.0% 0.0110 29.0)", + "25": "oklch(25.0% 0.0110 29.0)", + "26": "oklch(26.0% 0.0110 29.0)", + "27": "oklch(27.0% 0.0110 29.0)", + "28": "oklch(28.0% 0.0110 29.0)", + "29": "oklch(29.0% 0.0110 29.0)", + "30": "oklch(30.0% 0.0110 29.0)", + "31": "oklch(31.0% 0.0110 29.0)", + "32": "oklch(32.0% 0.0110 29.0)", + "33": "oklch(33.0% 0.0110 29.0)", + "34": "oklch(34.0% 0.0110 29.0)", + "35": "oklch(35.0% 0.0110 29.0)", + "36": "oklch(36.0% 0.0110 29.0)", + "37": "oklch(37.0% 0.0110 29.0)", + "38": "oklch(38.0% 0.0110 29.0)", + "39": "oklch(39.0% 0.0110 29.0)", + "40": "oklch(40.0% 0.0110 29.0)", + "41": "oklch(41.0% 0.0110 29.0)", + "42": "oklch(42.0% 0.0110 29.0)", + "43": "oklch(43.0% 0.0110 29.0)", + "44": "oklch(44.0% 0.0110 29.0)", + "45": "oklch(45.0% 0.0110 29.0)", + "46": "oklch(46.0% 0.0110 29.0)", + "47": "oklch(47.0% 0.0110 29.0)", + "48": "oklch(48.0% 0.0110 29.0)", + "49": "oklch(49.0% 0.0110 29.0)", + "50": "oklch(50.0% 0.0110 29.0)", + "51": "oklch(51.0% 0.0110 29.0)", + "52": "oklch(52.0% 0.0110 29.0)", + "53": "oklch(53.0% 0.0110 29.0)", + "54": "oklch(54.0% 0.0110 29.0)", + "55": "oklch(55.0% 0.0110 29.0)", + "56": "oklch(56.0% 0.0110 29.0)", + "57": "oklch(57.0% 0.0110 29.0)", + "58": "oklch(58.0% 0.0110 29.0)", + "59": "oklch(59.0% 0.0110 29.0)", + "60": "oklch(60.0% 0.0110 29.0)", + "61": "oklch(61.0% 0.0110 29.0)", + "62": "oklch(62.0% 0.0110 29.0)", + "63": "oklch(63.0% 0.0110 29.0)", + "64": "oklch(64.0% 0.0110 29.0)", + "65": "oklch(65.0% 0.0110 29.0)", + "66": "oklch(66.0% 0.0110 29.0)", + "67": "oklch(67.0% 0.0110 29.0)", + "68": "oklch(68.0% 0.0110 29.0)", + "69": "oklch(69.0% 0.0110 29.0)", + "70": "oklch(70.0% 0.0110 29.0)", + "71": "oklch(71.0% 0.0110 29.0)", + "72": "oklch(72.0% 0.0110 29.0)", + "73": "oklch(73.0% 0.0110 29.0)", + "74": "oklch(74.0% 0.0110 29.0)", + "75": "oklch(75.0% 0.0110 29.0)", + "76": "oklch(76.0% 0.0110 29.0)", + "77": "oklch(77.0% 0.0110 29.0)", + "78": "oklch(78.0% 0.0110 29.0)", + "79": "oklch(79.0% 0.0110 29.0)", + "80": "oklch(80.0% 0.0110 29.0)", + "81": "oklch(81.0% 0.0110 29.0)", + "82": "oklch(82.0% 0.0110 29.0)", + "83": "oklch(83.0% 0.0110 29.0)", + "84": "oklch(84.0% 0.0110 29.0)", + "85": "oklch(85.0% 0.0110 29.0)", + "86": "oklch(86.0% 0.0110 29.0)", + "87": "oklch(87.0% 0.0110 29.0)", + "88": "oklch(88.0% 0.0110 29.0)", + "89": "oklch(89.0% 0.0110 29.0)", + "90": "oklch(90.0% 0.0110 29.0)", + "91": "oklch(91.0% 0.0110 29.0)", + "92": "oklch(92.0% 0.0110 29.0)", + "93": "oklch(93.0% 0.0110 29.0)", + "94": "oklch(94.0% 0.0110 29.0)", + "95": "oklch(95.0% 0.0110 29.0)", + "96": "oklch(96.0% 0.0110 29.0)", + "97": "oklch(97.0% 0.0110 29.0)", + "98": "oklch(98.0% 0.0097 29.0)" }, "chaparral": { - "l15": "oklch(15% 0.011 62.5)", - "l20": "oklch(20% 0.011 62.5)", - "l25": "oklch(25% 0.011 62.5)", - "l30": "oklch(30% 0.011 62.5)", - "l35": "oklch(35% 0.011 62.5)", - "l40": "oklch(40% 0.011 62.5)", - "l45": "oklch(45% 0.011 62.5)", - "l50": "oklch(50% 0.011 62.5)", - "l55": "oklch(55% 0.011 62.5)", - "l60": "oklch(60% 0.011 62.5)", - "l65": "oklch(65% 0.011 62.5)", - "l70": "oklch(70% 0.011 62.5)", - "l75": "oklch(75% 0.011 62.5)", - "l80": "oklch(80% 0.011 62.5)", - "l85": "oklch(85% 0.011 62.5)", - "l90": "oklch(90% 0.011 62.5)", - "l95": "oklch(95% 0.011 62.5)", - "l98": "oklch(97.5% 0.011 62.5)" + "10": "oklch(10.0% 0.0110 62.5)", + "11": "oklch(11.0% 0.0110 62.5)", + "12": "oklch(12.0% 0.0110 62.5)", + "13": "oklch(13.0% 0.0110 62.5)", + "14": "oklch(14.0% 0.0110 62.5)", + "15": "oklch(15.0% 0.0110 62.5)", + "16": "oklch(16.0% 0.0110 62.5)", + "17": "oklch(17.0% 0.0110 62.5)", + "18": "oklch(18.0% 0.0110 62.5)", + "19": "oklch(19.0% 0.0110 62.5)", + "20": "oklch(20.0% 0.0110 62.5)", + "21": "oklch(21.0% 0.0110 62.5)", + "22": "oklch(22.0% 0.0110 62.5)", + "23": "oklch(23.0% 0.0110 62.5)", + "24": "oklch(24.0% 0.0110 62.5)", + "25": "oklch(25.0% 0.0110 62.5)", + "26": "oklch(26.0% 0.0110 62.5)", + "27": "oklch(27.0% 0.0110 62.5)", + "28": "oklch(28.0% 0.0110 62.5)", + "29": "oklch(29.0% 0.0110 62.5)", + "30": "oklch(30.0% 0.0110 62.5)", + "31": "oklch(31.0% 0.0110 62.5)", + "32": "oklch(32.0% 0.0110 62.5)", + "33": "oklch(33.0% 0.0110 62.5)", + "34": "oklch(34.0% 0.0110 62.5)", + "35": "oklch(35.0% 0.0110 62.5)", + "36": "oklch(36.0% 0.0110 62.5)", + "37": "oklch(37.0% 0.0110 62.5)", + "38": "oklch(38.0% 0.0110 62.5)", + "39": "oklch(39.0% 0.0110 62.5)", + "40": "oklch(40.0% 0.0110 62.5)", + "41": "oklch(41.0% 0.0110 62.5)", + "42": "oklch(42.0% 0.0110 62.5)", + "43": "oklch(43.0% 0.0110 62.5)", + "44": "oklch(44.0% 0.0110 62.5)", + "45": "oklch(45.0% 0.0110 62.5)", + "46": "oklch(46.0% 0.0110 62.5)", + "47": "oklch(47.0% 0.0110 62.5)", + "48": "oklch(48.0% 0.0110 62.5)", + "49": "oklch(49.0% 0.0110 62.5)", + "50": "oklch(50.0% 0.0110 62.5)", + "51": "oklch(51.0% 0.0110 62.5)", + "52": "oklch(52.0% 0.0110 62.5)", + "53": "oklch(53.0% 0.0110 62.5)", + "54": "oklch(54.0% 0.0110 62.5)", + "55": "oklch(55.0% 0.0110 62.5)", + "56": "oklch(56.0% 0.0110 62.5)", + "57": "oklch(57.0% 0.0110 62.5)", + "58": "oklch(58.0% 0.0110 62.5)", + "59": "oklch(59.0% 0.0110 62.5)", + "60": "oklch(60.0% 0.0110 62.5)", + "61": "oklch(61.0% 0.0110 62.5)", + "62": "oklch(62.0% 0.0110 62.5)", + "63": "oklch(63.0% 0.0110 62.5)", + "64": "oklch(64.0% 0.0110 62.5)", + "65": "oklch(65.0% 0.0110 62.5)", + "66": "oklch(66.0% 0.0110 62.5)", + "67": "oklch(67.0% 0.0110 62.5)", + "68": "oklch(68.0% 0.0110 62.5)", + "69": "oklch(69.0% 0.0110 62.5)", + "70": "oklch(70.0% 0.0110 62.5)", + "71": "oklch(71.0% 0.0110 62.5)", + "72": "oklch(72.0% 0.0110 62.5)", + "73": "oklch(73.0% 0.0110 62.5)", + "74": "oklch(74.0% 0.0110 62.5)", + "75": "oklch(75.0% 0.0110 62.5)", + "76": "oklch(76.0% 0.0110 62.5)", + "77": "oklch(77.0% 0.0110 62.5)", + "78": "oklch(78.0% 0.0110 62.5)", + "79": "oklch(79.0% 0.0110 62.5)", + "80": "oklch(80.0% 0.0110 62.5)", + "81": "oklch(81.0% 0.0110 62.5)", + "82": "oklch(82.0% 0.0110 62.5)", + "83": "oklch(83.0% 0.0110 62.5)", + "84": "oklch(84.0% 0.0110 62.5)", + "85": "oklch(85.0% 0.0110 62.5)", + "86": "oklch(86.0% 0.0110 62.5)", + "87": "oklch(87.0% 0.0110 62.5)", + "88": "oklch(88.0% 0.0110 62.5)", + "89": "oklch(89.0% 0.0110 62.5)", + "90": "oklch(90.0% 0.0110 62.5)", + "91": "oklch(91.0% 0.0110 62.5)", + "92": "oklch(92.0% 0.0110 62.5)", + "93": "oklch(93.0% 0.0110 62.5)", + "94": "oklch(94.0% 0.0110 62.5)", + "95": "oklch(95.0% 0.0110 62.5)", + "96": "oklch(96.0% 0.0110 62.5)", + "97": "oklch(97.0% 0.0110 62.5)", + "98": "oklch(98.0% 0.0110 62.5)" }, "savanna": { - "l15": "oklch(15% 0.011 104)", - "l20": "oklch(20% 0.011 104)", - "l25": "oklch(25% 0.011 104)", - "l30": "oklch(30% 0.011 104)", - "l35": "oklch(35% 0.011 104)", - "l40": "oklch(40% 0.011 104)", - "l45": "oklch(45% 0.011 104)", - "l50": "oklch(50% 0.011 104)", - "l55": "oklch(55% 0.011 104)", - "l60": "oklch(60% 0.011 104)", - "l65": "oklch(65% 0.011 104)", - "l70": "oklch(70% 0.011 104)", - "l75": "oklch(75% 0.011 104)", - "l80": "oklch(80% 0.011 104)", - "l85": "oklch(85% 0.011 104)", - "l90": "oklch(90% 0.011 104)", - "l95": "oklch(95% 0.011 104)", - "l98": "oklch(97.5% 0.011 104)" + "10": "oklch(10.0% 0.0110 104.0)", + "11": "oklch(11.0% 0.0110 104.0)", + "12": "oklch(12.0% 0.0110 104.0)", + "13": "oklch(13.0% 0.0110 104.0)", + "14": "oklch(14.0% 0.0110 104.0)", + "15": "oklch(15.0% 0.0110 104.0)", + "16": "oklch(16.0% 0.0110 104.0)", + "17": "oklch(17.0% 0.0110 104.0)", + "18": "oklch(18.0% 0.0110 104.0)", + "19": "oklch(19.0% 0.0110 104.0)", + "20": "oklch(20.0% 0.0110 104.0)", + "21": "oklch(21.0% 0.0110 104.0)", + "22": "oklch(22.0% 0.0110 104.0)", + "23": "oklch(23.0% 0.0110 104.0)", + "24": "oklch(24.0% 0.0110 104.0)", + "25": "oklch(25.0% 0.0110 104.0)", + "26": "oklch(26.0% 0.0110 104.0)", + "27": "oklch(27.0% 0.0110 104.0)", + "28": "oklch(28.0% 0.0110 104.0)", + "29": "oklch(29.0% 0.0110 104.0)", + "30": "oklch(30.0% 0.0110 104.0)", + "31": "oklch(31.0% 0.0110 104.0)", + "32": "oklch(32.0% 0.0110 104.0)", + "33": "oklch(33.0% 0.0110 104.0)", + "34": "oklch(34.0% 0.0110 104.0)", + "35": "oklch(35.0% 0.0110 104.0)", + "36": "oklch(36.0% 0.0110 104.0)", + "37": "oklch(37.0% 0.0110 104.0)", + "38": "oklch(38.0% 0.0110 104.0)", + "39": "oklch(39.0% 0.0110 104.0)", + "40": "oklch(40.0% 0.0110 104.0)", + "41": "oklch(41.0% 0.0110 104.0)", + "42": "oklch(42.0% 0.0110 104.0)", + "43": "oklch(43.0% 0.0110 104.0)", + "44": "oklch(44.0% 0.0110 104.0)", + "45": "oklch(45.0% 0.0110 104.0)", + "46": "oklch(46.0% 0.0110 104.0)", + "47": "oklch(47.0% 0.0110 104.0)", + "48": "oklch(48.0% 0.0110 104.0)", + "49": "oklch(49.0% 0.0110 104.0)", + "50": "oklch(50.0% 0.0110 104.0)", + "51": "oklch(51.0% 0.0110 104.0)", + "52": "oklch(52.0% 0.0110 104.0)", + "53": "oklch(53.0% 0.0110 104.0)", + "54": "oklch(54.0% 0.0110 104.0)", + "55": "oklch(55.0% 0.0110 104.0)", + "56": "oklch(56.0% 0.0110 104.0)", + "57": "oklch(57.0% 0.0110 104.0)", + "58": "oklch(58.0% 0.0110 104.0)", + "59": "oklch(59.0% 0.0110 104.0)", + "60": "oklch(60.0% 0.0110 104.0)", + "61": "oklch(61.0% 0.0110 104.0)", + "62": "oklch(62.0% 0.0110 104.0)", + "63": "oklch(63.0% 0.0110 104.0)", + "64": "oklch(64.0% 0.0110 104.0)", + "65": "oklch(65.0% 0.0110 104.0)", + "66": "oklch(66.0% 0.0110 104.0)", + "67": "oklch(67.0% 0.0110 104.0)", + "68": "oklch(68.0% 0.0110 104.0)", + "69": "oklch(69.0% 0.0110 104.0)", + "70": "oklch(70.0% 0.0110 104.0)", + "71": "oklch(71.0% 0.0110 104.0)", + "72": "oklch(72.0% 0.0110 104.0)", + "73": "oklch(73.0% 0.0110 104.0)", + "74": "oklch(74.0% 0.0110 104.0)", + "75": "oklch(75.0% 0.0110 104.0)", + "76": "oklch(76.0% 0.0110 104.0)", + "77": "oklch(77.0% 0.0110 104.0)", + "78": "oklch(78.0% 0.0110 104.0)", + "79": "oklch(79.0% 0.0110 104.0)", + "80": "oklch(80.0% 0.0110 104.0)", + "81": "oklch(81.0% 0.0110 104.0)", + "82": "oklch(82.0% 0.0110 104.0)", + "83": "oklch(83.0% 0.0110 104.0)", + "84": "oklch(84.0% 0.0110 104.0)", + "85": "oklch(85.0% 0.0110 104.0)", + "86": "oklch(86.0% 0.0110 104.0)", + "87": "oklch(87.0% 0.0110 104.0)", + "88": "oklch(88.0% 0.0110 104.0)", + "89": "oklch(89.0% 0.0110 104.0)", + "90": "oklch(90.0% 0.0110 104.0)", + "91": "oklch(91.0% 0.0110 104.0)", + "92": "oklch(92.0% 0.0110 104.0)", + "93": "oklch(93.0% 0.0110 104.0)", + "94": "oklch(94.0% 0.0110 104.0)", + "95": "oklch(95.0% 0.0110 104.0)", + "96": "oklch(96.0% 0.0110 104.0)", + "97": "oklch(97.0% 0.0110 104.0)", + "98": "oklch(98.0% 0.0110 104.0)" }, "grassland": { - "l15": "oklch(15.01% 0.011 148)", - "l20": "oklch(20% 0.011 148)", - "l25": "oklch(25% 0.011 148)", - "l30": "oklch(30% 0.011 148)", - "l35": "oklch(35% 0.011 148)", - "l40": "oklch(40% 0.011 148)", - "l45": "oklch(45% 0.011 148)", - "l50": "oklch(50% 0.011 148)", - "l55": "oklch(55% 0.011 148)", - "l60": "oklch(60% 0.011 148)", - "l65": "oklch(65% 0.011 148)", - "l70": "oklch(70% 0.011 148)", - "l75": "oklch(75% 0.011 148)", - "l80": "oklch(80% 0.011 148)", - "l85": "oklch(85% 0.011 148)", - "l90": "oklch(90% 0.011 148)", - "l95": "oklch(95% 0.011 148)", - "l98": "oklch(97.5% 0.011 148)" + "10": "oklch(10.0% 0.0110 148.0)", + "11": "oklch(11.0% 0.0110 148.0)", + "12": "oklch(12.0% 0.0110 148.0)", + "13": "oklch(13.0% 0.0110 148.0)", + "14": "oklch(14.0% 0.0110 148.0)", + "15": "oklch(15.0% 0.0110 148.0)", + "16": "oklch(16.0% 0.0110 148.0)", + "17": "oklch(17.0% 0.0110 148.0)", + "18": "oklch(18.0% 0.0110 148.0)", + "19": "oklch(19.0% 0.0110 148.0)", + "20": "oklch(20.0% 0.0110 148.0)", + "21": "oklch(21.0% 0.0110 148.0)", + "22": "oklch(22.0% 0.0110 148.0)", + "23": "oklch(23.0% 0.0110 148.0)", + "24": "oklch(24.0% 0.0110 148.0)", + "25": "oklch(25.0% 0.0110 148.0)", + "26": "oklch(26.0% 0.0110 148.0)", + "27": "oklch(27.0% 0.0110 148.0)", + "28": "oklch(28.0% 0.0110 148.0)", + "29": "oklch(29.0% 0.0110 148.0)", + "30": "oklch(30.0% 0.0110 148.0)", + "31": "oklch(31.0% 0.0110 148.0)", + "32": "oklch(32.0% 0.0110 148.0)", + "33": "oklch(33.0% 0.0110 148.0)", + "34": "oklch(34.0% 0.0110 148.0)", + "35": "oklch(35.0% 0.0110 148.0)", + "36": "oklch(36.0% 0.0110 148.0)", + "37": "oklch(37.0% 0.0110 148.0)", + "38": "oklch(38.0% 0.0110 148.0)", + "39": "oklch(39.0% 0.0110 148.0)", + "40": "oklch(40.0% 0.0110 148.0)", + "41": "oklch(41.0% 0.0110 148.0)", + "42": "oklch(42.0% 0.0110 148.0)", + "43": "oklch(43.0% 0.0110 148.0)", + "44": "oklch(44.0% 0.0110 148.0)", + "45": "oklch(45.0% 0.0110 148.0)", + "46": "oklch(46.0% 0.0110 148.0)", + "47": "oklch(47.0% 0.0110 148.0)", + "48": "oklch(48.0% 0.0110 148.0)", + "49": "oklch(49.0% 0.0110 148.0)", + "50": "oklch(50.0% 0.0110 148.0)", + "51": "oklch(51.0% 0.0110 148.0)", + "52": "oklch(52.0% 0.0110 148.0)", + "53": "oklch(53.0% 0.0110 148.0)", + "54": "oklch(54.0% 0.0110 148.0)", + "55": "oklch(55.0% 0.0110 148.0)", + "56": "oklch(56.0% 0.0110 148.0)", + "57": "oklch(57.0% 0.0110 148.0)", + "58": "oklch(58.0% 0.0110 148.0)", + "59": "oklch(59.0% 0.0110 148.0)", + "60": "oklch(60.0% 0.0110 148.0)", + "61": "oklch(61.0% 0.0110 148.0)", + "62": "oklch(62.0% 0.0110 148.0)", + "63": "oklch(63.0% 0.0110 148.0)", + "64": "oklch(64.0% 0.0110 148.0)", + "65": "oklch(65.0% 0.0110 148.0)", + "66": "oklch(66.0% 0.0110 148.0)", + "67": "oklch(67.0% 0.0110 148.0)", + "68": "oklch(68.0% 0.0110 148.0)", + "69": "oklch(69.0% 0.0110 148.0)", + "70": "oklch(70.0% 0.0110 148.0)", + "71": "oklch(71.0% 0.0110 148.0)", + "72": "oklch(72.0% 0.0110 148.0)", + "73": "oklch(73.0% 0.0110 148.0)", + "74": "oklch(74.0% 0.0110 148.0)", + "75": "oklch(75.0% 0.0110 148.0)", + "76": "oklch(76.0% 0.0110 148.0)", + "77": "oklch(77.0% 0.0110 148.0)", + "78": "oklch(78.0% 0.0110 148.0)", + "79": "oklch(79.0% 0.0110 148.0)", + "80": "oklch(80.0% 0.0110 148.0)", + "81": "oklch(81.0% 0.0110 148.0)", + "82": "oklch(82.0% 0.0110 148.0)", + "83": "oklch(83.0% 0.0110 148.0)", + "84": "oklch(84.0% 0.0110 148.0)", + "85": "oklch(85.0% 0.0110 148.0)", + "86": "oklch(86.0% 0.0110 148.0)", + "87": "oklch(87.0% 0.0110 148.0)", + "88": "oklch(88.0% 0.0110 148.0)", + "89": "oklch(89.0% 0.0110 148.0)", + "90": "oklch(90.0% 0.0110 148.0)", + "91": "oklch(91.0% 0.0110 148.0)", + "92": "oklch(92.0% 0.0110 148.0)", + "93": "oklch(93.0% 0.0110 148.0)", + "94": "oklch(94.0% 0.0110 148.0)", + "95": "oklch(95.0% 0.0110 148.0)", + "96": "oklch(96.0% 0.0110 148.0)", + "97": "oklch(97.0% 0.0110 148.0)", + "98": "oklch(98.0% 0.0110 148.0)" }, "tundra": { - "l15": "oklch(15% 0.011 262)", - "l20": "oklch(20% 0.011 262)", - "l25": "oklch(25% 0.011 262)", - "l30": "oklch(30% 0.011 262)", - "l35": "oklch(35% 0.011 262)", - "l40": "oklch(40% 0.011 262)", - "l45": "oklch(45% 0.011 262)", - "l50": "oklch(50% 0.011 262)", - "l55": "oklch(55% 0.011 262)", - "l60": "oklch(60% 0.011 262)", - "l65": "oklch(65% 0.011 262)", - "l70": "oklch(70% 0.011 262)", - "l75": "oklch(75% 0.011 262)", - "l80": "oklch(80% 0.011 262)", - "l85": "oklch(85% 0.011 262)", - "l90": "oklch(90% 0.011 262)", - "l95": "oklch(95% 0.011 262)", - "l98": "oklch(97.5% 0.011 262)" + "10": "oklch(10.0% 0.0110 262.0)", + "11": "oklch(11.0% 0.0110 262.0)", + "12": "oklch(12.0% 0.0110 262.0)", + "13": "oklch(13.0% 0.0110 262.0)", + "14": "oklch(14.0% 0.0110 262.0)", + "15": "oklch(15.0% 0.0110 262.0)", + "16": "oklch(16.0% 0.0110 262.0)", + "17": "oklch(17.0% 0.0110 262.0)", + "18": "oklch(18.0% 0.0110 262.0)", + "19": "oklch(19.0% 0.0110 262.0)", + "20": "oklch(20.0% 0.0110 262.0)", + "21": "oklch(21.0% 0.0110 262.0)", + "22": "oklch(22.0% 0.0110 262.0)", + "23": "oklch(23.0% 0.0110 262.0)", + "24": "oklch(24.0% 0.0110 262.0)", + "25": "oklch(25.0% 0.0110 262.0)", + "26": "oklch(26.0% 0.0110 262.0)", + "27": "oklch(27.0% 0.0110 262.0)", + "28": "oklch(28.0% 0.0110 262.0)", + "29": "oklch(29.0% 0.0110 262.0)", + "30": "oklch(30.0% 0.0110 262.0)", + "31": "oklch(31.0% 0.0110 262.0)", + "32": "oklch(32.0% 0.0110 262.0)", + "33": "oklch(33.0% 0.0110 262.0)", + "34": "oklch(34.0% 0.0110 262.0)", + "35": "oklch(35.0% 0.0110 262.0)", + "36": "oklch(36.0% 0.0110 262.0)", + "37": "oklch(37.0% 0.0110 262.0)", + "38": "oklch(38.0% 0.0110 262.0)", + "39": "oklch(39.0% 0.0110 262.0)", + "40": "oklch(40.0% 0.0110 262.0)", + "41": "oklch(41.0% 0.0110 262.0)", + "42": "oklch(42.0% 0.0110 262.0)", + "43": "oklch(43.0% 0.0110 262.0)", + "44": "oklch(44.0% 0.0110 262.0)", + "45": "oklch(45.0% 0.0110 262.0)", + "46": "oklch(46.0% 0.0110 262.0)", + "47": "oklch(47.0% 0.0110 262.0)", + "48": "oklch(48.0% 0.0110 262.0)", + "49": "oklch(49.0% 0.0110 262.0)", + "50": "oklch(50.0% 0.0110 262.0)", + "51": "oklch(51.0% 0.0110 262.0)", + "52": "oklch(52.0% 0.0110 262.0)", + "53": "oklch(53.0% 0.0110 262.0)", + "54": "oklch(54.0% 0.0110 262.0)", + "55": "oklch(55.0% 0.0110 262.0)", + "56": "oklch(56.0% 0.0110 262.0)", + "57": "oklch(57.0% 0.0110 262.0)", + "58": "oklch(58.0% 0.0110 262.0)", + "59": "oklch(59.0% 0.0110 262.0)", + "60": "oklch(60.0% 0.0110 262.0)", + "61": "oklch(61.0% 0.0110 262.0)", + "62": "oklch(62.0% 0.0110 262.0)", + "63": "oklch(63.0% 0.0110 262.0)", + "64": "oklch(64.0% 0.0110 262.0)", + "65": "oklch(65.0% 0.0110 262.0)", + "66": "oklch(66.0% 0.0110 262.0)", + "67": "oklch(67.0% 0.0110 262.0)", + "68": "oklch(68.0% 0.0110 262.0)", + "69": "oklch(69.0% 0.0110 262.0)", + "70": "oklch(70.0% 0.0110 262.0)", + "71": "oklch(71.0% 0.0110 262.0)", + "72": "oklch(72.0% 0.0110 262.0)", + "73": "oklch(73.0% 0.0110 262.0)", + "74": "oklch(74.0% 0.0110 262.0)", + "75": "oklch(75.0% 0.0110 262.0)", + "76": "oklch(76.0% 0.0110 262.0)", + "77": "oklch(77.0% 0.0110 262.0)", + "78": "oklch(78.0% 0.0110 262.0)", + "79": "oklch(79.0% 0.0110 262.0)", + "80": "oklch(80.0% 0.0110 262.0)", + "81": "oklch(81.0% 0.0110 262.0)", + "82": "oklch(82.0% 0.0110 262.0)", + "83": "oklch(83.0% 0.0110 262.0)", + "84": "oklch(84.0% 0.0110 262.0)", + "85": "oklch(85.0% 0.0110 262.0)", + "86": "oklch(86.0% 0.0110 262.0)", + "87": "oklch(87.0% 0.0110 262.0)", + "88": "oklch(88.0% 0.0110 262.0)", + "89": "oklch(89.0% 0.0110 262.0)", + "90": "oklch(90.0% 0.0110 262.0)", + "91": "oklch(91.0% 0.0110 262.0)", + "92": "oklch(92.0% 0.0110 262.0)", + "93": "oklch(93.0% 0.0110 262.0)", + "94": "oklch(94.0% 0.0110 262.0)", + "95": "oklch(95.0% 0.0110 262.0)", + "96": "oklch(96.0% 0.0110 262.0)", + "97": "oklch(97.0% 0.0110 262.0)", + "98": "oklch(98.0% 0.0094 262.0)" }, "red": { - "l15": "oklch(15% 0.058 29)", - "l20": "oklch(20% 0.074 29)", - "l25": "oklch(25% 0.092 29)", - "l30": "oklch(30% 0.11 29)", - "l35": "oklch(35% 0.128 29)", - "l40": "oklch(40% 0.147 29)", - "l45": "oklch(45% 0.167 29)", - "l50": "oklch(50% 0.183 29)", - "l55": "oklch(55% 0.193 29)", - "l60": "oklch(60% 0.193 29)", - "l65": "oklch(65% 0.182 29)", - "l70": "oklch(70% 0.164 29)", - "l75": "oklch(75% 0.14 29)", - "l80": "oklch(80% 0.112 29)", - "l85": "oklch(85% 0.081 29)", - "l90": "oklch(90% 0.052 29)", - "l95": "oklch(95% 0.024 29)", - "l98": "oklch(97.5% 0.012 29)" + "10": "oklch(10.0% 0.0391 29.0)", + "11": "oklch(11.0% 0.0429 29.0)", + "12": "oklch(12.0% 0.0468 29.0)", + "13": "oklch(13.0% 0.0506 29.0)", + "14": "oklch(14.0% 0.0545 29.0)", + "15": "oklch(15.0% 0.0583 29.0)", + "16": "oklch(16.0% 0.0621 29.0)", + "17": "oklch(17.0% 0.0659 29.0)", + "18": "oklch(18.0% 0.0697 29.0)", + "19": "oklch(19.0% 0.0735 29.0)", + "20": "oklch(20.0% 0.0773 29.0)", + "21": "oklch(21.0% 0.0810 29.0)", + "22": "oklch(22.0% 0.0847 29.0)", + "23": "oklch(23.0% 0.0885 29.0)", + "24": "oklch(24.0% 0.0922 29.0)", + "25": "oklch(25.0% 0.0958 29.0)", + "26": "oklch(26.0% 0.0995 29.0)", + "27": "oklch(27.0% 0.1031 29.0)", + "28": "oklch(28.0% 0.1067 29.0)", + "29": "oklch(29.0% 0.1103 29.0)", + "30": "oklch(30.0% 0.1139 29.0)", + "31": "oklch(31.0% 0.1174 29.0)", + "32": "oklch(32.0% 0.1209 29.0)", + "33": "oklch(33.0% 0.1244 29.0)", + "34": "oklch(34.0% 0.1278 29.0)", + "35": "oklch(35.0% 0.1312 29.0)", + "36": "oklch(36.0% 0.1346 29.0)", + "37": "oklch(37.0% 0.1378 29.0)", + "38": "oklch(38.0% 0.1411 29.0)", + "39": "oklch(39.0% 0.1443 29.0)", + "40": "oklch(40.0% 0.1474 29.0)", + "41": "oklch(41.0% 0.1505 29.0)", + "42": "oklch(42.0% 0.1535 29.0)", + "43": "oklch(43.0% 0.1564 29.0)", + "44": "oklch(44.0% 0.1592 29.0)", + "45": "oklch(45.0% 0.1619 29.0)", + "46": "oklch(46.0% 0.1645 29.0)", + "47": "oklch(47.0% 0.1670 29.0)", + "48": "oklch(48.0% 0.1694 29.0)", + "49": "oklch(49.0% 0.1716 29.0)", + "50": "oklch(50.0% 0.1737 29.0)", + "51": "oklch(51.0% 0.1756 29.0)", + "52": "oklch(52.0% 0.1774 29.0)", + "53": "oklch(53.0% 0.1789 29.0)", + "54": "oklch(54.0% 0.1802 29.0)", + "55": "oklch(55.0% 0.1813 29.0)", + "56": "oklch(56.0% 0.1821 29.0)", + "57": "oklch(57.0% 0.1827 29.0)", + "58": "oklch(58.0% 0.1829 29.0)", + "59": "oklch(59.0% 0.1829 29.0)", + "60": "oklch(60.0% 0.1825 29.0)", + "61": "oklch(61.0% 0.1819 29.0)", + "62": "oklch(62.0% 0.1809 29.0)", + "63": "oklch(63.0% 0.1795 29.0)", + "64": "oklch(64.0% 0.1778 29.0)", + "65": "oklch(65.0% 0.1758 29.0)", + "66": "oklch(66.0% 0.1735 29.0)", + "67": "oklch(67.0% 0.1709 29.0)", + "68": "oklch(68.0% 0.1680 29.0)", + "69": "oklch(69.0% 0.1648 29.0)", + "70": "oklch(70.0% 0.1613 29.0)", + "71": "oklch(71.0% 0.1576 29.0)", + "72": "oklch(72.0% 0.1537 29.0)", + "73": "oklch(73.0% 0.1496 29.0)", + "74": "oklch(74.0% 0.1453 29.0)", + "75": "oklch(75.0% 0.1408 29.0)", + "76": "oklch(76.0% 0.1361 29.0)", + "77": "oklch(77.0% 0.1313 29.0)", + "78": "oklch(78.0% 0.1264 29.0)", + "79": "oklch(79.0% 0.1213 29.0)", + "80": "oklch(80.0% 0.1147 29.0)", + "81": "oklch(81.0% 0.1079 29.0)", + "82": "oklch(82.0% 0.1012 29.0)", + "83": "oklch(83.0% 0.0947 29.0)", + "84": "oklch(84.0% 0.0883 29.0)", + "85": "oklch(85.0% 0.0820 29.0)", + "86": "oklch(86.0% 0.0758 29.0)", + "87": "oklch(87.0% 0.0697 29.0)", + "88": "oklch(88.0% 0.0638 29.0)", + "89": "oklch(89.0% 0.0579 29.0)", + "90": "oklch(90.0% 0.0522 29.0)", + "91": "oklch(91.0% 0.0466 29.0)", + "92": "oklch(92.0% 0.0410 29.0)", + "93": "oklch(93.0% 0.0356 29.0)", + "94": "oklch(94.0% 0.0302 29.0)", + "95": "oklch(95.0% 0.0250 29.0)", + "96": "oklch(96.0% 0.0198 29.0)", + "97": "oklch(97.0% 0.0147 29.0)", + "98": "oklch(98.0% 0.0097 29.0)" }, "orange": { - "l15": "oklch(15% 0.0301 62.5)", - "l20": "oklch(20% 0.038 62.5)", - "l25": "oklch(25% 0.046 62.5)", - "l30": "oklch(30% 0.058 62.5)", - "l35": "oklch(35% 0.07 62.5)", - "l40": "oklch(40% 0.084 62.5)", - "l45": "oklch(45% 0.1 62.5)", - "l50": "oklch(50% 0.114 62.5)", - "l55": "oklch(55% 0.125 62.5)", - "l60": "oklch(60% 0.134 62.5)", - "l65": "oklch(65% 0.138 62.5)", - "l70": "oklch(70% 0.136 62.5)", - "l75": "oklch(75% 0.128 62.5)", - "l80": "oklch(80% 0.112 62.5)", - "l85": "oklch(85% 0.092 62.5)", - "l90": "oklch(90% 0.064 62.5)", - "l95": "oklch(95% 0.032 62.5)", - "l98": "oklch(97.5% 0.008 62.5)" + "10": "oklch(10.0% 0.0213 62.5)", + "11": "oklch(11.0% 0.0234 62.5)", + "12": "oklch(12.0% 0.0256 62.5)", + "13": "oklch(13.0% 0.0277 62.5)", + "14": "oklch(14.0% 0.0298 62.5)", + "15": "oklch(15.0% 0.0319 62.5)", + "16": "oklch(16.0% 0.0340 62.5)", + "17": "oklch(17.0% 0.0361 62.5)", + "18": "oklch(18.0% 0.0382 62.5)", + "19": "oklch(19.0% 0.0403 62.5)", + "20": "oklch(20.0% 0.0424 62.5)", + "21": "oklch(21.0% 0.0445 62.5)", + "22": "oklch(22.0% 0.0465 62.5)", + "23": "oklch(23.0% 0.0486 62.5)", + "24": "oklch(24.0% 0.0507 62.5)", + "25": "oklch(25.0% 0.0527 62.5)", + "26": "oklch(26.0% 0.0548 62.5)", + "27": "oklch(27.0% 0.0569 62.5)", + "28": "oklch(28.0% 0.0589 62.5)", + "29": "oklch(29.0% 0.0609 62.5)", + "30": "oklch(30.0% 0.0630 62.5)", + "31": "oklch(31.0% 0.0650 62.5)", + "32": "oklch(32.0% 0.0670 62.5)", + "33": "oklch(33.0% 0.0690 62.5)", + "34": "oklch(34.0% 0.0710 62.5)", + "35": "oklch(35.0% 0.0730 62.5)", + "36": "oklch(36.0% 0.0749 62.5)", + "37": "oklch(37.0% 0.0769 62.5)", + "38": "oklch(38.0% 0.0788 62.5)", + "39": "oklch(39.0% 0.0808 62.5)", + "40": "oklch(40.0% 0.0827 62.5)", + "41": "oklch(41.0% 0.0846 62.5)", + "42": "oklch(42.0% 0.0864 62.5)", + "43": "oklch(43.0% 0.0883 62.5)", + "44": "oklch(44.0% 0.0901 62.5)", + "45": "oklch(45.0% 0.0919 62.5)", + "46": "oklch(46.0% 0.0937 62.5)", + "47": "oklch(47.0% 0.0954 62.5)", + "48": "oklch(48.0% 0.0971 62.5)", + "49": "oklch(49.0% 0.0987 62.5)", + "50": "oklch(50.0% 0.1004 62.5)", + "51": "oklch(51.0% 0.1019 62.5)", + "52": "oklch(52.0% 0.1034 62.5)", + "53": "oklch(53.0% 0.1049 62.5)", + "54": "oklch(54.0% 0.1062 62.5)", + "55": "oklch(55.0% 0.1075 62.5)", + "56": "oklch(56.0% 0.1087 62.5)", + "57": "oklch(57.0% 0.1098 62.5)", + "58": "oklch(58.0% 0.1108 62.5)", + "59": "oklch(59.0% 0.1117 62.5)", + "60": "oklch(60.0% 0.1124 62.5)", + "61": "oklch(61.0% 0.1130 62.5)", + "62": "oklch(62.0% 0.1134 62.5)", + "63": "oklch(63.0% 0.1136 62.5)", + "64": "oklch(64.0% 0.1136 62.5)", + "65": "oklch(65.0% 0.1133 62.5)", + "66": "oklch(66.0% 0.1129 62.5)", + "67": "oklch(67.0% 0.1121 62.5)", + "68": "oklch(68.0% 0.1111 62.5)", + "69": "oklch(69.0% 0.1099 62.5)", + "70": "oklch(70.0% 0.1083 62.5)", + "71": "oklch(71.0% 0.1066 62.5)", + "72": "oklch(72.0% 0.1045 62.5)", + "73": "oklch(73.0% 0.1023 62.5)", + "74": "oklch(74.0% 0.0998 62.5)", + "75": "oklch(75.0% 0.0971 62.5)", + "76": "oklch(76.0% 0.0942 62.5)", + "77": "oklch(77.0% 0.0912 62.5)", + "78": "oklch(78.0% 0.0880 62.5)", + "79": "oklch(79.0% 0.0847 62.5)", + "80": "oklch(80.0% 0.0812 62.5)", + "81": "oklch(81.0% 0.0777 62.5)", + "82": "oklch(82.0% 0.0740 62.5)", + "83": "oklch(83.0% 0.0703 62.5)", + "84": "oklch(84.0% 0.0665 62.5)", + "85": "oklch(85.0% 0.0627 62.5)", + "86": "oklch(86.0% 0.0587 62.5)", + "87": "oklch(87.0% 0.0547 62.5)", + "88": "oklch(88.0% 0.0507 62.5)", + "89": "oklch(89.0% 0.0466 62.5)", + "90": "oklch(90.0% 0.0425 62.5)", + "91": "oklch(91.0% 0.0384 62.5)", + "92": "oklch(92.0% 0.0342 62.5)", + "93": "oklch(93.0% 0.0300 62.5)", + "94": "oklch(94.0% 0.0258 62.5)", + "95": "oklch(95.0% 0.0215 62.5)", + "96": "oklch(96.0% 0.0173 62.5)", + "97": "oklch(97.0% 0.0130 62.5)", + "98": "oklch(98.0% 0.0087 62.5)" }, "yellow": { - "l15": "oklch(14.99% 0.02 104)", - "l20": "oklch(20% 0.024 104)", - "l25": "oklch(25% 0.03 104)", - "l30": "oklch(30% 0.036 104)", - "l35": "oklch(35% 0.044 104)", - "l40": "oklch(40% 0.05 104)", - "l45": "oklch(45% 0.06 104)", - "l50": "oklch(50% 0.068 104)", - "l55": "oklch(55% 0.076 104)", - "l60": "oklch(60% 0.082 104)", - "l65": "oklch(65% 0.088 104)", - "l70": "oklch(70% 0.088 104)", - "l75": "oklch(75% 0.086 104)", - "l80": "oklch(80% 0.082 104)", - "l85": "oklch(85% 0.072 104)", - "l90": "oklch(90% 0.058 104)", - "l95": "oklch(95% 0.04 104)", - "l98": "oklch(97.5% 0.016 104)" + "10": "oklch(10.0% 0.0114 104.0)", + "11": "oklch(11.0% 0.0125 104.0)", + "12": "oklch(12.0% 0.0136 104.0)", + "13": "oklch(13.0% 0.0147 104.0)", + "14": "oklch(14.0% 0.0159 104.0)", + "15": "oklch(15.0% 0.0170 104.0)", + "16": "oklch(16.0% 0.0181 104.0)", + "17": "oklch(17.0% 0.0192 104.0)", + "18": "oklch(18.0% 0.0203 104.0)", + "19": "oklch(19.0% 0.0215 104.0)", + "20": "oklch(20.0% 0.0226 104.0)", + "21": "oklch(21.0% 0.0237 104.0)", + "22": "oklch(22.0% 0.0248 104.0)", + "23": "oklch(23.0% 0.0259 104.0)", + "24": "oklch(24.0% 0.0270 104.0)", + "25": "oklch(25.0% 0.0281 104.0)", + "26": "oklch(26.0% 0.0292 104.0)", + "27": "oklch(27.0% 0.0303 104.0)", + "28": "oklch(28.0% 0.0314 104.0)", + "29": "oklch(29.0% 0.0325 104.0)", + "30": "oklch(30.0% 0.0336 104.0)", + "31": "oklch(31.0% 0.0347 104.0)", + "32": "oklch(32.0% 0.0358 104.0)", + "33": "oklch(33.0% 0.0369 104.0)", + "34": "oklch(34.0% 0.0379 104.0)", + "35": "oklch(35.0% 0.0390 104.0)", + "36": "oklch(36.0% 0.0401 104.0)", + "37": "oklch(37.0% 0.0411 104.0)", + "38": "oklch(38.0% 0.0422 104.0)", + "39": "oklch(39.0% 0.0433 104.0)", + "40": "oklch(40.0% 0.0443 104.0)", + "41": "oklch(41.0% 0.0453 104.0)", + "42": "oklch(42.0% 0.0464 104.0)", + "43": "oklch(43.0% 0.0474 104.0)", + "44": "oklch(44.0% 0.0484 104.0)", + "45": "oklch(45.0% 0.0494 104.0)", + "46": "oklch(46.0% 0.0504 104.0)", + "47": "oklch(47.0% 0.0514 104.0)", + "48": "oklch(48.0% 0.0523 104.0)", + "49": "oklch(49.0% 0.0533 104.0)", + "50": "oklch(50.0% 0.0542 104.0)", + "51": "oklch(51.0% 0.0552 104.0)", + "52": "oklch(52.0% 0.0561 104.0)", + "53": "oklch(53.0% 0.0569 104.0)", + "54": "oklch(54.0% 0.0578 104.0)", + "55": "oklch(55.0% 0.0586 104.0)", + "56": "oklch(56.0% 0.0594 104.0)", + "57": "oklch(57.0% 0.0602 104.0)", + "58": "oklch(58.0% 0.0610 104.0)", + "59": "oklch(59.0% 0.0616 104.0)", + "60": "oklch(60.0% 0.0623 104.0)", + "61": "oklch(61.0% 0.0629 104.0)", + "62": "oklch(62.0% 0.0634 104.0)", + "63": "oklch(63.0% 0.0639 104.0)", + "64": "oklch(64.0% 0.0643 104.0)", + "65": "oklch(65.0% 0.0646 104.0)", + "66": "oklch(66.0% 0.0648 104.0)", + "67": "oklch(67.0% 0.0649 104.0)", + "68": "oklch(68.0% 0.0649 104.0)", + "69": "oklch(69.0% 0.0648 104.0)", + "70": "oklch(70.0% 0.0645 104.0)", + "71": "oklch(71.0% 0.0641 104.0)", + "72": "oklch(72.0% 0.0634 104.0)", + "73": "oklch(73.0% 0.0627 104.0)", + "74": "oklch(74.0% 0.0617 104.0)", + "75": "oklch(75.0% 0.0606 104.0)", + "76": "oklch(76.0% 0.0593 104.0)", + "77": "oklch(77.0% 0.0578 104.0)", + "78": "oklch(78.0% 0.0562 104.0)", + "79": "oklch(79.0% 0.0544 104.0)", + "80": "oklch(80.0% 0.0525 104.0)", + "81": "oklch(81.0% 0.0504 104.0)", + "82": "oklch(82.0% 0.0483 104.0)", + "83": "oklch(83.0% 0.0461 104.0)", + "84": "oklch(84.0% 0.0437 104.0)", + "85": "oklch(85.0% 0.0413 104.0)", + "86": "oklch(86.0% 0.0388 104.0)", + "87": "oklch(87.0% 0.0363 104.0)", + "88": "oklch(88.0% 0.0337 104.0)", + "89": "oklch(89.0% 0.0311 104.0)", + "90": "oklch(90.0% 0.0284 104.0)", + "91": "oklch(91.0% 0.0256 104.0)", + "92": "oklch(92.0% 0.0229 104.0)", + "93": "oklch(93.0% 0.0201 104.0)", + "94": "oklch(94.0% 0.0173 104.0)", + "95": "oklch(95.0% 0.0145 104.0)", + "96": "oklch(96.0% 0.0116 104.0)", + "97": "oklch(97.0% 0.0087 104.0)", + "98": "oklch(98.0% 0.0058 104.0)" }, "green": { - "l15": "oklch(14.99% 0.0401 148)", - "l20": "oklch(20% 0.048 148)", - "l25": "oklch(25% 0.056 148)", - "l30": "oklch(30% 0.064 148)", - "l35": "oklch(35% 0.072 148)", - "l40": "oklch(40% 0.08 148)", - "l45": "oklch(45% 0.09 148)", - "l50": "oklch(50% 0.098 148)", - "l55": "oklch(55% 0.104 148)", - "l60": "oklch(60% 0.108 148)", - "l65": "oklch(65% 0.11 148)", - "l70": "oklch(70% 0.108 148)", - "l75": "oklch(75% 0.102 148)", - "l80": "oklch(80% 0.094 148)", - "l85": "oklch(85% 0.084 148)", - "l90": "oklch(90% 0.072 148)", - "l95": "oklch(95% 0.05 148)", - "l98": "oklch(97.5% 0.024 148)" + "10": "oklch(10.0% 0.0158 148.0)", + "11": "oklch(11.0% 0.0174 148.0)", + "12": "oklch(12.0% 0.0190 148.0)", + "13": "oklch(13.0% 0.0206 148.0)", + "14": "oklch(14.0% 0.0221 148.0)", + "15": "oklch(15.0% 0.0237 148.0)", + "16": "oklch(16.0% 0.0253 148.0)", + "17": "oklch(17.0% 0.0268 148.0)", + "18": "oklch(18.0% 0.0284 148.0)", + "19": "oklch(19.0% 0.0299 148.0)", + "20": "oklch(20.0% 0.0315 148.0)", + "21": "oklch(21.0% 0.0330 148.0)", + "22": "oklch(22.0% 0.0346 148.0)", + "23": "oklch(23.0% 0.0361 148.0)", + "24": "oklch(24.0% 0.0377 148.0)", + "25": "oklch(25.0% 0.0392 148.0)", + "26": "oklch(26.0% 0.0407 148.0)", + "27": "oklch(27.0% 0.0423 148.0)", + "28": "oklch(28.0% 0.0438 148.0)", + "29": "oklch(29.0% 0.0453 148.0)", + "30": "oklch(30.0% 0.0468 148.0)", + "31": "oklch(31.0% 0.0483 148.0)", + "32": "oklch(32.0% 0.0498 148.0)", + "33": "oklch(33.0% 0.0513 148.0)", + "34": "oklch(34.0% 0.0528 148.0)", + "35": "oklch(35.0% 0.0543 148.0)", + "36": "oklch(36.0% 0.0558 148.0)", + "37": "oklch(37.0% 0.0572 148.0)", + "38": "oklch(38.0% 0.0587 148.0)", + "39": "oklch(39.0% 0.0601 148.0)", + "40": "oklch(40.0% 0.0616 148.0)", + "41": "oklch(41.0% 0.0630 148.0)", + "42": "oklch(42.0% 0.0644 148.0)", + "43": "oklch(43.0% 0.0658 148.0)", + "44": "oklch(44.0% 0.0672 148.0)", + "45": "oklch(45.0% 0.0685 148.0)", + "46": "oklch(46.0% 0.0699 148.0)", + "47": "oklch(47.0% 0.0712 148.0)", + "48": "oklch(48.0% 0.0725 148.0)", + "49": "oklch(49.0% 0.0738 148.0)", + "50": "oklch(50.0% 0.0750 148.0)", + "51": "oklch(51.0% 0.0762 148.0)", + "52": "oklch(52.0% 0.0774 148.0)", + "53": "oklch(53.0% 0.0786 148.0)", + "54": "oklch(54.0% 0.0797 148.0)", + "55": "oklch(55.0% 0.0807 148.0)", + "56": "oklch(56.0% 0.0817 148.0)", + "57": "oklch(57.0% 0.0827 148.0)", + "58": "oklch(58.0% 0.0835 148.0)", + "59": "oklch(59.0% 0.0843 148.0)", + "60": "oklch(60.0% 0.0850 148.0)", + "61": "oklch(61.0% 0.0857 148.0)", + "62": "oklch(62.0% 0.0862 148.0)", + "63": "oklch(63.0% 0.0865 148.0)", + "64": "oklch(64.0% 0.0868 148.0)", + "65": "oklch(65.0% 0.0869 148.0)", + "66": "oklch(66.0% 0.0868 148.0)", + "67": "oklch(67.0% 0.0865 148.0)", + "68": "oklch(68.0% 0.0861 148.0)", + "69": "oklch(69.0% 0.0854 148.0)", + "70": "oklch(70.0% 0.0845 148.0)", + "71": "oklch(71.0% 0.0835 148.0)", + "72": "oklch(72.0% 0.0822 148.0)", + "73": "oklch(73.0% 0.0807 148.0)", + "74": "oklch(74.0% 0.0790 148.0)", + "75": "oklch(75.0% 0.0771 148.0)", + "76": "oklch(76.0% 0.0750 148.0)", + "77": "oklch(77.0% 0.0728 148.0)", + "78": "oklch(78.0% 0.0704 148.0)", + "79": "oklch(79.0% 0.0679 148.0)", + "80": "oklch(80.0% 0.0652 148.0)", + "81": "oklch(81.0% 0.0625 148.0)", + "82": "oklch(82.0% 0.0596 148.0)", + "83": "oklch(83.0% 0.0567 148.0)", + "84": "oklch(84.0% 0.0537 148.0)", + "85": "oklch(85.0% 0.0506 148.0)", + "86": "oklch(86.0% 0.0475 148.0)", + "87": "oklch(87.0% 0.0443 148.0)", + "88": "oklch(88.0% 0.0411 148.0)", + "89": "oklch(89.0% 0.0378 148.0)", + "90": "oklch(90.0% 0.0345 148.0)", + "91": "oklch(91.0% 0.0312 148.0)", + "92": "oklch(92.0% 0.0278 148.0)", + "93": "oklch(93.0% 0.0244 148.0)", + "94": "oklch(94.0% 0.0210 148.0)", + "95": "oklch(95.0% 0.0175 148.0)", + "96": "oklch(96.0% 0.0140 148.0)", + "97": "oklch(97.0% 0.0106 148.0)", + "98": "oklch(98.0% 0.0071 148.0)" }, "blue": { - "l15": "oklch(15% 0.06 262)", - "l20": "oklch(20% 0.072 262)", - "l25": "oklch(25% 0.084 262)", - "l30": "oklch(30% 0.096 262)", - "l35": "oklch(35% 0.106 262)", - "l40": "oklch(40% 0.116 262.01)", - "l45": "oklch(45% 0.124 262)", - "l50": "oklch(50% 0.13 262)", - "l55": "oklch(55% 0.132 262)", - "l60": "oklch(60% 0.128 262)", - "l65": "oklch(65% 0.122 262)", - "l70": "oklch(70% 0.11 262)", - "l75": "oklch(75% 0.096 262)", - "l80": "oklch(80% 0.08 262)", - "l85": "oklch(85% 0.064 262)", - "l90": "oklch(90% 0.044 262)", - "l95": "oklch(95% 0.023 262)", - "l98": "oklch(97.5% 0.011 262)" + "10": "oklch(10.0% 0.0285 262.0)", + "11": "oklch(11.0% 0.0313 262.0)", + "12": "oklch(12.0% 0.0341 262.0)", + "13": "oklch(13.0% 0.0370 262.0)", + "14": "oklch(14.0% 0.0398 262.0)", + "15": "oklch(15.0% 0.0426 262.0)", + "16": "oklch(16.0% 0.0454 262.0)", + "17": "oklch(17.0% 0.0482 262.0)", + "18": "oklch(18.0% 0.0509 262.0)", + "19": "oklch(19.0% 0.0537 262.0)", + "20": "oklch(20.0% 0.0565 262.0)", + "21": "oklch(21.0% 0.0592 262.0)", + "22": "oklch(22.0% 0.0620 262.0)", + "23": "oklch(23.0% 0.0647 262.0)", + "24": "oklch(24.0% 0.0674 262.0)", + "25": "oklch(25.0% 0.0701 262.0)", + "26": "oklch(26.0% 0.0728 262.0)", + "27": "oklch(27.0% 0.0755 262.0)", + "28": "oklch(28.0% 0.0782 262.0)", + "29": "oklch(29.0% 0.0809 262.0)", + "30": "oklch(30.0% 0.0835 262.0)", + "31": "oklch(31.0% 0.0861 262.0)", + "32": "oklch(32.0% 0.0887 262.0)", + "33": "oklch(33.0% 0.0913 262.0)", + "34": "oklch(34.0% 0.0939 262.0)", + "35": "oklch(35.0% 0.0964 262.0)", + "36": "oklch(36.0% 0.0990 262.0)", + "37": "oklch(37.0% 0.1015 262.0)", + "38": "oklch(38.0% 0.1039 262.0)", + "39": "oklch(39.0% 0.1064 262.0)", + "40": "oklch(40.0% 0.1088 262.0)", + "41": "oklch(41.0% 0.1111 262.0)", + "42": "oklch(42.0% 0.1135 262.0)", + "43": "oklch(43.0% 0.1157 262.0)", + "44": "oklch(44.0% 0.1180 262.0)", + "45": "oklch(45.0% 0.1202 262.0)", + "46": "oklch(46.0% 0.1223 262.0)", + "47": "oklch(47.0% 0.1244 262.0)", + "48": "oklch(48.0% 0.1264 262.0)", + "49": "oklch(49.0% 0.1283 262.0)", + "50": "oklch(50.0% 0.1301 262.0)", + "51": "oklch(51.0% 0.1319 262.0)", + "52": "oklch(52.0% 0.1336 262.0)", + "53": "oklch(53.0% 0.1351 262.0)", + "54": "oklch(54.0% 0.1365 262.0)", + "55": "oklch(55.0% 0.1378 262.0)", + "56": "oklch(56.0% 0.1390 262.0)", + "57": "oklch(57.0% 0.1400 262.0)", + "58": "oklch(58.0% 0.1408 262.0)", + "59": "oklch(59.0% 0.1414 262.0)", + "60": "oklch(60.0% 0.1419 262.0)", + "61": "oklch(61.0% 0.1421 262.0)", + "62": "oklch(62.0% 0.1421 262.0)", + "63": "oklch(63.0% 0.1418 262.0)", + "64": "oklch(64.0% 0.1413 262.0)", + "65": "oklch(65.0% 0.1405 262.0)", + "66": "oklch(66.0% 0.1394 262.0)", + "67": "oklch(67.0% 0.1381 262.0)", + "68": "oklch(68.0% 0.1365 262.0)", + "69": "oklch(69.0% 0.1346 262.0)", + "70": "oklch(70.0% 0.1324 262.0)", + "71": "oklch(71.0% 0.1300 262.0)", + "72": "oklch(72.0% 0.1273 262.0)", + "73": "oklch(73.0% 0.1244 262.0)", + "74": "oklch(74.0% 0.1212 262.0)", + "75": "oklch(75.0% 0.1179 262.0)", + "76": "oklch(76.0% 0.1144 262.0)", + "77": "oklch(77.0% 0.1107 262.0)", + "78": "oklch(78.0% 0.1068 262.0)", + "79": "oklch(79.0% 0.1028 262.0)", + "80": "oklch(80.0% 0.0986 262.0)", + "81": "oklch(81.0% 0.0943 262.0)", + "82": "oklch(82.0% 0.0898 262.0)", + "83": "oklch(83.0% 0.0845 262.0)", + "84": "oklch(84.0% 0.0792 262.0)", + "85": "oklch(85.0% 0.0739 262.0)", + "86": "oklch(86.0% 0.0687 262.0)", + "87": "oklch(87.0% 0.0636 262.0)", + "88": "oklch(88.0% 0.0584 262.0)", + "89": "oklch(89.0% 0.0534 262.0)", + "90": "oklch(90.0% 0.0483 262.0)", + "91": "oklch(91.0% 0.0433 262.0)", + "92": "oklch(92.0% 0.0384 262.0)", + "93": "oklch(93.0% 0.0334 262.0)", + "94": "oklch(94.0% 0.0285 262.0)", + "95": "oklch(95.0% 0.0237 262.0)", + "96": "oklch(96.0% 0.0189 262.0)", + "97": "oklch(97.0% 0.0141 262.0)", + "98": "oklch(98.0% 0.0094 262.0)" } } diff --git a/templates/groups/palette/monobiome.toml b/templates/groups/palette/monobiome.toml index 09b75f5..88212e3 100644 --- a/templates/groups/palette/monobiome.toml +++ b/templates/groups/palette/monobiome.toml @@ -1,221 +1,1002 @@ -version = "1.1.1" +version = "1.2.0" -[default] +[alpine] +l10 = "#030303" +l11 = "#040404" +l12 = "#060606" +l13 = "#070707" +l14 = "#090909" l15 = "#0b0b0b" +l16 = "#0d0d0d" +l17 = "#0f0f0f" +l18 = "#121212" +l19 = "#141414" l20 = "#161616" +l21 = "#181818" +l22 = "#1b1b1b" +l23 = "#1d1d1d" +l24 = "#1f1f1f" l25 = "#222222" +l26 = "#242424" +l27 = "#262626" +l28 = "#292929" +l29 = "#2b2b2b" l30 = "#2e2e2e" +l31 = "#303030" +l32 = "#333333" +l33 = "#353535" +l34 = "#383838" l35 = "#3a3a3a" +l36 = "#3d3d3d" +l37 = "#404040" +l38 = "#424242" +l39 = "#454545" l40 = "#484848" +l41 = "#4a4a4a" +l42 = "#4d4d4d" +l43 = "#505050" +l44 = "#525252" l45 = "#555555" +l46 = "#585858" +l47 = "#5b5b5b" +l48 = "#5d5d5d" +l49 = "#606060" l50 = "#636363" +l51 = "#666666" +l52 = "#696969" +l53 = "#6c6c6c" +l54 = "#6f6f6f" l55 = "#717171" +l56 = "#747474" +l57 = "#777777" +l58 = "#7a7a7a" +l59 = "#7d7d7d" l60 = "#808080" +l61 = "#838383" +l62 = "#868686" +l63 = "#898989" +l64 = "#8c8c8c" l65 = "#8f8f8f" +l66 = "#929292" +l67 = "#959595" +l68 = "#989898" +l69 = "#9b9b9b" l70 = "#9e9e9e" +l71 = "#a1a1a1" +l72 = "#a4a4a4" +l73 = "#a8a8a8" +l74 = "#ababab" l75 = "#aeaeae" +l76 = "#b1b1b1" +l77 = "#b4b4b4" +l78 = "#b7b7b7" +l79 = "#bababa" l80 = "#bebebe" +l81 = "#c1c1c1" +l82 = "#c4c4c4" +l83 = "#c7c7c7" +l84 = "#cacaca" l85 = "#cecece" +l86 = "#d1d1d1" +l87 = "#d4d4d4" +l88 = "#d7d7d7" +l89 = "#dbdbdb" l90 = "#dedede" +l91 = "#e1e1e1" +l92 = "#e4e4e4" +l93 = "#e8e8e8" +l94 = "#ebebeb" l95 = "#eeeeee" -l98 = "#f7f7f7" +l96 = "#f2f2f2" +l97 = "#f5f5f5" +l98 = "#f8f8f8" [badlands] +l10 = "#060302" +l11 = "#070303" +l12 = "#090504" +l13 = "#0b0605" +l14 = "#0d0807" l15 = "#0f0909" +l16 = "#120c0b" +l17 = "#140e0d" +l18 = "#16100f" +l19 = "#181211" l20 = "#1b1413" +l21 = "#1d1615" +l22 = "#1f1918" +l23 = "#221b1a" +l24 = "#241d1c" l25 = "#27201f" +l26 = "#292221" +l27 = "#2c2523" +l28 = "#2e2726" +l29 = "#312928" l30 = "#332c2b" +l31 = "#362e2d" +l32 = "#383130" +l33 = "#3b3332" +l34 = "#3d3635" l35 = "#403837" +l36 = "#433b3a" +l37 = "#453e3c" +l38 = "#48403f" +l39 = "#4b4342" l40 = "#4d4644" +l41 = "#504847" +l42 = "#534b4a" +l43 = "#564e4c" +l44 = "#58504f" l45 = "#5b5352" +l46 = "#5e5654" +l47 = "#615957" +l48 = "#645b5a" +l49 = "#675e5d" l50 = "#696160" +l51 = "#6c6462" +l52 = "#6f6765" +l53 = "#726a68" +l54 = "#756c6b" l55 = "#786f6e" +l56 = "#7b7271" +l57 = "#7e7574" +l58 = "#817877" +l59 = "#847b79" l60 = "#877e7c" +l61 = "#8a817f" +l62 = "#8d8482" +l63 = "#908785" +l64 = "#938a88" l65 = "#968d8b" +l66 = "#99908e" +l67 = "#9c9391" +l68 = "#9f9694" +l69 = "#a29997" l70 = "#a59c9a" +l71 = "#a89f9d" +l72 = "#aba2a1" +l73 = "#aea5a4" +l74 = "#b2a8a7" l75 = "#b5abaa" +l76 = "#b8afad" +l77 = "#bbb2b0" +l78 = "#beb5b3" +l79 = "#c1b8b6" l80 = "#c5bbba" +l81 = "#c8bebd" +l82 = "#cbc2c0" +l83 = "#cec5c3" +l84 = "#d2c8c6" l85 = "#d5cbca" +l86 = "#d8cecd" +l87 = "#dbd2d0" +l88 = "#dfd5d3" +l89 = "#e2d8d7" l90 = "#e5dbda" +l91 = "#e8dfdd" +l92 = "#ece2e0" +l93 = "#efe5e4" +l94 = "#f2e9e7" l95 = "#f6ecea" -l98 = "#fef4f2" +l96 = "#f9efee" +l97 = "#fcf3f1" +l98 = "#fff6f5" [chaparral] +l10 = "#050301" +l11 = "#070402" +l12 = "#080503" +l13 = "#0a0704" +l14 = "#0c0805" l15 = "#0f0a07" +l16 = "#110c09" +l17 = "#130e0b" +l18 = "#15110d" +l19 = "#17130f" l20 = "#1a1511" +l21 = "#1c1713" +l22 = "#1e1a15" +l23 = "#211c18" +l24 = "#231e1a" l25 = "#26211c" +l26 = "#28231f" +l27 = "#2a2521" +l28 = "#2d2823" +l29 = "#2f2a26" l30 = "#322d28" +l31 = "#342f2b" +l32 = "#37322d" +l33 = "#3a3430" +l34 = "#3c3732" l35 = "#3f3935" +l36 = "#413c37" +l37 = "#443f3a" +l38 = "#47413c" +l39 = "#49443f" l40 = "#4c4642" +l41 = "#4f4944" +l42 = "#524c47" +l43 = "#544f4a" +l44 = "#57514c" l45 = "#5a544f" +l46 = "#5d5752" +l47 = "#5f5a55" +l48 = "#625c57" +l49 = "#655f5a" l50 = "#68625d" +l51 = "#6b6560" +l52 = "#6e6863" +l53 = "#716a65" +l54 = "#736d68" l55 = "#76706b" +l56 = "#79736e" +l57 = "#7c7671" +l58 = "#7f7974" +l59 = "#827c77" l60 = "#857f7a" +l61 = "#88827d" +l62 = "#8b8580" +l63 = "#8e8882" +l64 = "#918b85" l65 = "#948e88" +l66 = "#97918b" +l67 = "#9a948e" +l68 = "#9d9791" +l69 = "#a09a95" l70 = "#a49d98" +l71 = "#a7a09b" +l72 = "#aaa39e" +l73 = "#ada6a1" +l74 = "#b0a9a4" l75 = "#b3ada7" +l76 = "#b6b0aa" +l77 = "#bab3ad" +l78 = "#bdb6b0" +l79 = "#c0b9b3" l80 = "#c3bcb7" +l81 = "#c6bfba" +l82 = "#c9c3bd" +l83 = "#cdc6c0" +l84 = "#d0c9c3" l85 = "#d3ccc7" +l86 = "#d6d0ca" +l87 = "#dad3cd" +l88 = "#ddd6d0" +l89 = "#e0d9d3" l90 = "#e4ddd7" +l91 = "#e7e0da" +l92 = "#eae3dd" +l93 = "#ede6e1" +l94 = "#f1eae4" l95 = "#f4ede7" -l98 = "#fcf5ef" +l96 = "#f7f0ea" +l97 = "#fbf4ee" +l98 = "#fef7f1" [savanna] +l10 = "#040301" +l11 = "#050502" +l12 = "#060603" +l13 = "#080704" +l14 = "#0a0905" l15 = "#0c0b06" +l16 = "#0e0e08" +l17 = "#10100a" +l18 = "#12120c" +l19 = "#14140e" l20 = "#171611" +l21 = "#191913" +l22 = "#1b1b15" +l23 = "#1e1d17" +l24 = "#20201a" l25 = "#22221c" +l26 = "#25241e" +l27 = "#272721" +l28 = "#2a2923" +l29 = "#2c2c25" l30 = "#2f2e28" +l31 = "#31312a" +l32 = "#34332d" +l33 = "#36362f" +l34 = "#393832" l35 = "#3b3b34" +l36 = "#3e3d37" +l37 = "#404039" +l38 = "#43433c" +l39 = "#46453f" l40 = "#484841" +l41 = "#4b4b44" +l42 = "#4e4d47" +l43 = "#515049" +l44 = "#53534c" l45 = "#56564f" +l46 = "#595851" +l47 = "#5c5b54" +l48 = "#5e5e57" +l49 = "#61615a" l50 = "#64645d" +l51 = "#67665f" +l52 = "#6a6962" +l53 = "#6d6c65" +l54 = "#6f6f68" l55 = "#72726b" +l56 = "#75756e" +l57 = "#787870" +l58 = "#7b7b73" +l59 = "#7e7e76" l60 = "#818179" +l61 = "#84847c" +l62 = "#87877f" +l63 = "#8a8a82" +l64 = "#8d8d85" l65 = "#909088" +l66 = "#93938b" +l67 = "#96968e" +l68 = "#999991" +l69 = "#9c9c94" l70 = "#9f9f97" +l71 = "#a2a29a" +l72 = "#a5a59d" +l73 = "#a9a8a0" +l74 = "#acaba3" l75 = "#afaea7" +l76 = "#b2b1aa" +l77 = "#b5b5ad" +l78 = "#b8b8b0" +l79 = "#bbbbb3" l80 = "#bfbeb6" +l81 = "#c2c1b9" +l82 = "#c5c5bd" +l83 = "#c8c8c0" +l84 = "#cbcbc3" l85 = "#cfcec6" +l86 = "#d2d1c9" +l87 = "#d5d5cd" +l88 = "#d8d8d0" +l89 = "#dcdbd3" l90 = "#dfded6" +l91 = "#e2e2da" +l92 = "#e5e5dd" +l93 = "#e9e8e0" +l94 = "#ecece3" l95 = "#efefe7" -l98 = "#f8f7ef" +l96 = "#f3f2ea" +l97 = "#f6f6ed" +l98 = "#f9f9f1" [grassland] +l10 = "#020402" +l11 = "#030503" +l12 = "#040704" +l13 = "#050805" +l14 = "#060a07" l15 = "#080c09" +l16 = "#0a0f0b" +l17 = "#0c110d" +l18 = "#0e130f" +l19 = "#111511" l20 = "#131713" +l21 = "#151a15" +l22 = "#171c18" +l23 = "#1a1e1a" +l24 = "#1c211c" l25 = "#1e231f" +l26 = "#212621" +l27 = "#232823" +l28 = "#252a26" +l29 = "#282d28" l30 = "#2a2f2b" +l31 = "#2d322d" +l32 = "#2f3430" +l33 = "#323732" +l34 = "#343a35" l35 = "#373c37" +l36 = "#393f3a" +l37 = "#3c413c" +l38 = "#3f443f" +l39 = "#414742" l40 = "#444944" +l41 = "#474c47" +l42 = "#494f4a" +l43 = "#4c524c" +l44 = "#4f544f" l45 = "#515752" +l46 = "#545a55" +l47 = "#575d57" +l48 = "#5a5f5a" +l49 = "#5c625d" l50 = "#5f6560" +l51 = "#626863" +l52 = "#656b65" +l53 = "#686e68" +l54 = "#6b706b" l55 = "#6d736e" +l56 = "#707671" +l57 = "#737974" +l58 = "#767c77" +l59 = "#797f7a" l60 = "#7c827d" +l61 = "#7f857f" +l62 = "#828882" +l63 = "#858b85" +l64 = "#888e88" l65 = "#8b918b" +l66 = "#8e948e" +l67 = "#919791" +l68 = "#949a94" +l69 = "#979d98" l70 = "#9aa09b" +l71 = "#9da39e" +l72 = "#a0a7a1" +l73 = "#a3aaa4" +l74 = "#a6ada7" l75 = "#a9b0aa" +l76 = "#adb3ad" +l77 = "#b0b6b0" +l78 = "#b3b9b3" +l79 = "#b6bdb7" l80 = "#b9c0ba" +l81 = "#bcc3bd" +l82 = "#c0c6c0" +l83 = "#c3c9c3" +l84 = "#c6cdc6" l85 = "#c9d0ca" +l86 = "#ccd3cd" +l87 = "#d0d6d0" +l88 = "#d3dad3" +l89 = "#d6ddd7" l90 = "#d9e0da" +l91 = "#dde3dd" +l92 = "#e0e7e0" +l93 = "#e3eae4" +l94 = "#e6ede7" l95 = "#eaf1ea" -l98 = "#f2f9f3" +l96 = "#edf4ee" +l97 = "#f0f7f1" +l98 = "#f4fbf4" [tundra] +l10 = "#020306" +l11 = "#030408" +l12 = "#040609" +l13 = "#05070c" +l14 = "#07090e" l15 = "#090b10" +l16 = "#0b0d12" +l17 = "#0d0f14" +l18 = "#0f1217" +l19 = "#111419" l20 = "#13161b" +l21 = "#16181d" +l22 = "#181b20" +l23 = "#1a1d22" +l24 = "#1c1f25" l25 = "#1f2227" +l26 = "#212429" +l27 = "#23272c" +l28 = "#26292e" +l29 = "#282b31" l30 = "#2b2e33" +l31 = "#2d3036" +l32 = "#303339" +l33 = "#32353b" +l34 = "#35383e" l35 = "#373b40" +l36 = "#3a3d43" +l37 = "#3d4046" +l38 = "#3f4248" +l39 = "#42454b" l40 = "#44484e" +l41 = "#474a51" +l42 = "#4a4d53" +l43 = "#4c5056" +l44 = "#4f5359" l45 = "#52555c" +l46 = "#55585e" +l47 = "#575b61" +l48 = "#5a5e64" +l49 = "#5d6167" l50 = "#60636a" +l51 = "#63666d" +l52 = "#65696f" +l53 = "#686c72" +l54 = "#6b6f75" l55 = "#6e7278" +l56 = "#71757b" +l57 = "#74787e" +l58 = "#777a81" +l59 = "#7a7d84" l60 = "#7d8087" +l61 = "#80838a" +l62 = "#82868d" +l63 = "#858990" +l64 = "#888c93" l65 = "#8b8f96" +l66 = "#8e9299" +l67 = "#91959c" +l68 = "#95989f" +l69 = "#989ba2" l70 = "#9b9fa5" +l71 = "#9ea2a9" +l72 = "#a1a5ac" +l73 = "#a4a8af" +l74 = "#a7abb2" l75 = "#aaaeb5" +l76 = "#adb1b8" +l77 = "#b0b4bb" +l78 = "#b3b8bf" +l79 = "#b7bbc2" l80 = "#babec5" +l81 = "#bdc1c8" +l82 = "#c0c4cb" +l83 = "#c3c7cf" +l84 = "#c7cbd2" l85 = "#caced5" +l86 = "#cdd1d8" +l87 = "#d0d4dc" +l88 = "#d3d8df" +l89 = "#d7dbe2" l90 = "#dadee6" +l91 = "#dde1e9" +l92 = "#e1e5ec" +l93 = "#e4e8ef" +l94 = "#e7ebf3" l95 = "#eaeff6" -l98 = "#f3f7fe" +l96 = "#eef2f9" +l97 = "#f1f5fd" +l98 = "#f5f9ff" [red] +l10 = "#0d0000" +l11 = "#100000" +l12 = "#130000" +l13 = "#170000" +l14 = "#1a0100" l15 = "#1e0100" -l20 = "#300302" -l25 = "#440604" -l30 = "#590b07" -l35 = "#6e110b" -l40 = "#85160f" -l45 = "#9d1a13" -l50 = "#b42219" -l55 = "#ca2f24" -l60 = "#dc4234" -l65 = "#e95949" -l70 = "#f37060" -l75 = "#fa897a" -l80 = "#fea294" -l85 = "#febab0" +l16 = "#220101" +l17 = "#250101" +l18 = "#290101" +l19 = "#2d0201" +l20 = "#310201" +l21 = "#350201" +l22 = "#390302" +l23 = "#3d0302" +l24 = "#410302" +l25 = "#450403" +l26 = "#490503" +l27 = "#4d0503" +l28 = "#510604" +l29 = "#560704" +l30 = "#5a0805" +l31 = "#5e0906" +l32 = "#620a06" +l33 = "#670b07" +l34 = "#6b0d08" +l35 = "#6f0e09" +l36 = "#740f0a" +l37 = "#78110b" +l38 = "#7d120c" +l39 = "#81140e" +l40 = "#85150f" +l41 = "#8a1710" +l42 = "#8e1912" +l43 = "#931a13" +l44 = "#971c15" +l45 = "#9b1e16" +l46 = "#a02018" +l47 = "#a4221a" +l48 = "#a8241c" +l49 = "#ad271d" +l50 = "#b1291f" +l51 = "#b52c22" +l52 = "#b92e24" +l53 = "#bd3126" +l54 = "#c13428" +l55 = "#c5372b" +l56 = "#c93a2e" +l57 = "#cd3d31" +l58 = "#d04034" +l59 = "#d44437" +l60 = "#d7473a" +l61 = "#db4b3d" +l62 = "#de4f41" +l63 = "#e15344" +l64 = "#e45748" +l65 = "#e65b4c" +l66 = "#e96050" +l67 = "#eb6454" +l68 = "#ee6859" +l69 = "#f06d5d" +l70 = "#f27262" +l71 = "#f47666" +l72 = "#f67b6b" +l73 = "#f77f70" +l74 = "#f98474" +l75 = "#fa8979" +l76 = "#fc8d7e" +l77 = "#fd9283" +l78 = "#fe9788" +l79 = "#ff9c8d" +l80 = "#ffa193" +l81 = "#ffa699" +l82 = "#ffab9e" +l83 = "#ffb0a4" +l84 = "#ffb5aa" +l85 = "#ffbaaf" +l86 = "#ffbfb5" +l87 = "#ffc4ba" +l88 = "#ffc8c0" +l89 = "#ffcdc5" l90 = "#ffd2ca" -l95 = "#fee9e5" -l98 = "#fff4f2" +l91 = "#ffd6d0" +l92 = "#ffdbd5" +l93 = "#ffe0da" +l94 = "#ffe4e0" +l95 = "#ffe9e5" +l96 = "#ffedea" +l97 = "#fff2ef" +l98 = "#fff6f5" [orange] +l10 = "#070200" +l11 = "#090300" +l12 = "#0c0400" +l13 = "#0f0500" +l14 = "#120600" l15 = "#140801" -l20 = "#221203" -l25 = "#311c08" -l30 = "#42260a" -l35 = "#54310d" -l40 = "#673c0c" -l45 = "#7c4706" -l50 = "#905201" -l55 = "#a45e03" -l60 = "#b76b0c" -l65 = "#c97920" -l70 = "#d98937" -l75 = "#e79a51" -l80 = "#f1ad6f" -l85 = "#fac18f" -l90 = "#fed5b3" -l95 = "#ffead9" -l98 = "#fbf6f1" +l16 = "#170901" +l17 = "#1a0b01" +l18 = "#1d0d01" +l19 = "#200f01" +l20 = "#231101" +l21 = "#261302" +l22 = "#2a1502" +l23 = "#2d1702" +l24 = "#301903" +l25 = "#331b03" +l26 = "#361d03" +l27 = "#3a1f04" +l28 = "#3d2104" +l29 = "#402305" +l30 = "#442605" +l31 = "#472806" +l32 = "#4a2a07" +l33 = "#4e2c07" +l34 = "#512e08" +l35 = "#553109" +l36 = "#58330a" +l37 = "#5c350b" +l38 = "#5f380c" +l39 = "#633a0d" +l40 = "#673c0e" +l41 = "#6a3f0f" +l42 = "#6e4111" +l43 = "#714312" +l44 = "#754613" +l45 = "#794814" +l46 = "#7c4b16" +l47 = "#804d17" +l48 = "#845018" +l49 = "#87521a" +l50 = "#8b551b" +l51 = "#8f571d" +l52 = "#925a1f" +l53 = "#965c20" +l54 = "#9a5f22" +l55 = "#9d6224" +l56 = "#a16426" +l57 = "#a56728" +l58 = "#a86a2b" +l59 = "#ac6d2d" +l60 = "#af7030" +l61 = "#b37232" +l62 = "#b67535" +l63 = "#b97838" +l64 = "#bd7b3c" +l65 = "#c07e3f" +l66 = "#c38243" +l67 = "#c68547" +l68 = "#c9884b" +l69 = "#cc8b4f" +l70 = "#ce8f53" +l71 = "#d19258" +l72 = "#d3965d" +l73 = "#d69962" +l74 = "#d89d67" +l75 = "#daa06c" +l76 = "#dca471" +l77 = "#dea777" +l78 = "#e0ab7c" +l79 = "#e2af82" +l80 = "#e4b387" +l81 = "#e6b68d" +l82 = "#e7ba93" +l83 = "#e9be99" +l84 = "#ebc29e" +l85 = "#ecc5a4" +l86 = "#eec9aa" +l87 = "#efcdb0" +l88 = "#f1d1b6" +l89 = "#f2d5bc" +l90 = "#f3d9c2" +l91 = "#f5dcc8" +l92 = "#f6e0ce" +l93 = "#f7e4d4" +l94 = "#f8e8da" +l95 = "#faece0" +l96 = "#fbf0e6" +l97 = "#fcf3ec" +l98 = "#fdf7f3" [yellow] -l15 = "#0c0c03" -l20 = "#181709" -l25 = "#242211" -l30 = "#312f19" -l35 = "#3e3c20" -l40 = "#4c4928" -l45 = "#5b572e" -l50 = "#6a6535" -l55 = "#79743d" -l60 = "#888346" -l65 = "#989250" -l70 = "#a7a15f" -l75 = "#b7b170" -l80 = "#c6c182" -l85 = "#d5d19a" -l90 = "#e4e1b4" -l95 = "#f2f0d2" -l98 = "#f8f8eb" +l10 = "#040301" +l11 = "#050502" +l12 = "#060602" +l13 = "#080803" +l14 = "#0a0904" +l15 = "#0c0c04" +l16 = "#0e0e05" +l17 = "#111006" +l18 = "#131207" +l19 = "#151409" +l20 = "#18170a" +l21 = "#1a190c" +l22 = "#1c1b0d" +l23 = "#1f1e0f" +l24 = "#212011" +l25 = "#242212" +l26 = "#262514" +l27 = "#292715" +l28 = "#2b2a17" +l29 = "#2e2c19" +l30 = "#302f1b" +l31 = "#33311c" +l32 = "#36341e" +l33 = "#383620" +l34 = "#3b3921" +l35 = "#3e3c23" +l36 = "#403e25" +l37 = "#434127" +l38 = "#464429" +l39 = "#49462b" +l40 = "#4b492c" +l41 = "#4e4c2e" +l42 = "#514e30" +l43 = "#545132" +l44 = "#575434" +l45 = "#5a5736" +l46 = "#5c5a38" +l47 = "#5f5c3a" +l48 = "#625f3c" +l49 = "#65623e" +l50 = "#686540" +l51 = "#6b6842" +l52 = "#6e6b44" +l53 = "#716e46" +l54 = "#747149" +l55 = "#77744b" +l56 = "#7a764d" +l57 = "#7d794f" +l58 = "#807c51" +l59 = "#837f54" +l60 = "#868256" +l61 = "#898559" +l62 = "#8c885b" +l63 = "#8f8b5e" +l64 = "#928e60" +l65 = "#959263" +l66 = "#989566" +l67 = "#9c9869" +l68 = "#9f9b6c" +l69 = "#a29e6f" +l70 = "#a5a172" +l71 = "#a8a475" +l72 = "#aba779" +l73 = "#aeaa7c" +l74 = "#b1ad80" +l75 = "#b4b084" +l76 = "#b7b388" +l77 = "#bab78c" +l78 = "#bdba90" +l79 = "#c0bd95" +l80 = "#c3c099" +l81 = "#c6c39e" +l82 = "#c9c6a2" +l83 = "#ccc9a7" +l84 = "#cfccac" +l85 = "#d2d0b1" +l86 = "#d5d3b6" +l87 = "#d8d6bb" +l88 = "#dbd9c0" +l89 = "#dedcc5" +l90 = "#e1dfca" +l91 = "#e4e2cf" +l92 = "#e7e6d4" +l93 = "#eae9da" +l94 = "#edecdf" +l95 = "#f0efe4" +l96 = "#f3f2ea" +l97 = "#f6f5ef" +l98 = "#f9f9f4" [green] -l15 = "#010f03" -l20 = "#041c09" -l25 = "#0b2911" -l30 = "#14361a" -l35 = "#1c4524" -l40 = "#25532e" -l45 = "#2e6337" -l50 = "#377242" -l55 = "#42824e" -l60 = "#4f925a" -l65 = "#5da268" -l70 = "#6eb178" -l75 = "#80c089" -l80 = "#94cf9c" -l85 = "#a9ddaf" -l90 = "#beecc4" -l95 = "#d9f8dc" -l98 = "#edfcee" +l10 = "#010402" +l11 = "#020602" +l12 = "#020703" +l13 = "#030904" +l14 = "#040c05" +l15 = "#050e06" +l16 = "#061007" +l17 = "#071309" +l18 = "#08150a" +l19 = "#0a170c" +l20 = "#0c1a0e" +l21 = "#0d1c0f" +l22 = "#0f1f11" +l23 = "#102213" +l24 = "#122415" +l25 = "#142717" +l26 = "#162919" +l27 = "#172c1a" +l28 = "#192f1c" +l29 = "#1b321e" +l30 = "#1d3420" +l31 = "#1e3722" +l32 = "#203a24" +l33 = "#223d26" +l34 = "#243f28" +l35 = "#26422a" +l36 = "#28452c" +l37 = "#2a482e" +l38 = "#2c4b30" +l39 = "#2d4e32" +l40 = "#2f5134" +l41 = "#315437" +l42 = "#335739" +l43 = "#355a3b" +l44 = "#375d3d" +l45 = "#3a603f" +l46 = "#3c6341" +l47 = "#3e6644" +l48 = "#406946" +l49 = "#426c48" +l50 = "#446f4b" +l51 = "#46724d" +l52 = "#49754f" +l53 = "#4b7852" +l54 = "#4d7c54" +l55 = "#507f56" +l56 = "#528259" +l57 = "#54855b" +l58 = "#57885e" +l59 = "#598b60" +l60 = "#5c8e63" +l61 = "#5e9166" +l62 = "#619568" +l63 = "#64986b" +l64 = "#679b6e" +l65 = "#6a9e71" +l66 = "#6da174" +l67 = "#70a477" +l68 = "#73a77a" +l69 = "#76aa7d" +l70 = "#7aad81" +l71 = "#7db084" +l72 = "#81b388" +l73 = "#85b68b" +l74 = "#89b98f" +l75 = "#8dbc93" +l76 = "#91bf96" +l77 = "#95c29a" +l78 = "#99c49e" +l79 = "#9ec7a2" +l80 = "#a2caa6" +l81 = "#a6cdab" +l82 = "#abcfaf" +l83 = "#afd2b3" +l84 = "#b4d5b7" +l85 = "#b8d7bc" +l86 = "#bddac0" +l87 = "#c1ddc4" +l88 = "#c6dfc9" +l89 = "#cbe2cd" +l90 = "#cfe5d1" +l91 = "#d4e7d6" +l92 = "#d9eada" +l93 = "#deeddf" +l94 = "#e2efe3" +l95 = "#e7f2e8" +l96 = "#ecf5ed" +l97 = "#f1f7f1" +l98 = "#f5faf6" [blue] -l15 = "#010924" -l20 = "#041336" -l25 = "#091f49" -l30 = "#112b5d" -l35 = "#1a3771" -l40 = "#234485" -l45 = "#2d5299" -l50 = "#3860ac" -l55 = "#456fbe" -l60 = "#557ecc" -l65 = "#658ed9" -l70 = "#799ee3" -l75 = "#8daeeb" -l80 = "#a2bef2" -l85 = "#b7cff9" -l90 = "#cedffc" +l10 = "#01030c" +l11 = "#01040f" +l12 = "#020512" +l13 = "#020716" +l14 = "#020819" +l15 = "#030a1d" +l16 = "#040c20" +l17 = "#040e24" +l18 = "#051028" +l19 = "#06132b" +l20 = "#07152f" +l21 = "#081733" +l22 = "#0a1937" +l23 = "#0b1b3b" +l24 = "#0c1e3f" +l25 = "#0e2043" +l26 = "#0f2247" +l27 = "#11254b" +l28 = "#12274f" +l29 = "#142953" +l30 = "#152c57" +l31 = "#172e5b" +l32 = "#18315f" +l33 = "#1a3364" +l34 = "#1b3668" +l35 = "#1d386c" +l36 = "#1f3b70" +l37 = "#203d75" +l38 = "#224079" +l39 = "#24427d" +l40 = "#254582" +l41 = "#274886" +l42 = "#294a8a" +l43 = "#2b4d8e" +l44 = "#2c5093" +l45 = "#2e5297" +l46 = "#30559b" +l47 = "#3258a0" +l48 = "#345aa4" +l49 = "#365da8" +l50 = "#3860ad" +l51 = "#3a63b1" +l52 = "#3c66b5" +l53 = "#3e69b9" +l54 = "#416cbd" +l55 = "#436ec1" +l56 = "#4571c5" +l57 = "#4874c9" +l58 = "#4a77cd" +l59 = "#4d7ad1" +l60 = "#507dd4" +l61 = "#5280d8" +l62 = "#5584db" +l63 = "#5887de" +l64 = "#5b8ae1" +l65 = "#5f8de4" +l66 = "#6290e7" +l67 = "#6593ea" +l68 = "#6997ec" +l69 = "#6c9aee" +l70 = "#709df0" +l71 = "#74a0f2" +l72 = "#78a4f4" +l73 = "#7ca7f6" +l74 = "#80aaf7" +l75 = "#85aef9" +l76 = "#89b1fa" +l77 = "#8db4fb" +l78 = "#92b8fc" +l79 = "#96bbfd" +l80 = "#9bbefe" +l81 = "#a0c1fe" +l82 = "#a4c5ff" +l83 = "#aac8ff" +l84 = "#afcbff" +l85 = "#b4cfff" +l86 = "#b9d2ff" +l87 = "#bed5ff" +l88 = "#c3d8ff" +l89 = "#c8dcff" +l90 = "#cddfff" +l91 = "#d2e2ff" +l92 = "#d7e5ff" +l93 = "#dce9ff" +l94 = "#e1ecff" l95 = "#e6efff" -l98 = "#f3f7fe" +l96 = "#ebf2ff" +l97 = "#f0f5ff" +l98 = "#f5f9ff" diff --git a/templates/groups/theme/default-alpine-monobiome-dark.toml b/templates/groups/theme/default-alpine-monobiome-dark.toml index 4cf1e6f..41c5dae 100644 --- a/templates/groups/theme/default-alpine-monobiome-dark.toml +++ b/templates/groups/theme/default-alpine-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# ALPINE +# MONOBIOME :mode=dark :harshness=default +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-alpine-monobiome-light.toml b/templates/groups/theme/default-alpine-monobiome-light.toml index 32ae377..dc82b60 100644 --- a/templates/groups/theme/default-alpine-monobiome-light.toml +++ b/templates/groups/theme/default-alpine-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# ALPINE +# MONOBIOME :mode=light :harshness=default +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/default-badlands-monobiome-dark.toml b/templates/groups/theme/default-badlands-monobiome-dark.toml index 55a7781..89783e6 100644 --- a/templates/groups/theme/default-badlands-monobiome-dark.toml +++ b/templates/groups/theme/default-badlands-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# BADLANDS +# MONOBIOME :mode=dark :harshness=default +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-badlands-monobiome-light.toml b/templates/groups/theme/default-badlands-monobiome-light.toml index f2071af..cf8093d 100644 --- a/templates/groups/theme/default-badlands-monobiome-light.toml +++ b/templates/groups/theme/default-badlands-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# BADLANDS +# MONOBIOME :mode=light :harshness=default +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/default-chaparral-monobiome-dark.toml b/templates/groups/theme/default-chaparral-monobiome-dark.toml index 60949b9..3d25dfc 100644 --- a/templates/groups/theme/default-chaparral-monobiome-dark.toml +++ b/templates/groups/theme/default-chaparral-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# CHAPARRAL +# MONOBIOME :mode=dark :harshness=default +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-chaparral-monobiome-light.toml b/templates/groups/theme/default-chaparral-monobiome-light.toml index 9b674aa..118a899 100644 --- a/templates/groups/theme/default-chaparral-monobiome-light.toml +++ b/templates/groups/theme/default-chaparral-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# CHAPARRAL +# MONOBIOME :mode=light :harshness=default +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/default-grassland-monobiome-dark.toml b/templates/groups/theme/default-grassland-monobiome-dark.toml index 6cb3b63..0f37cce 100644 --- a/templates/groups/theme/default-grassland-monobiome-dark.toml +++ b/templates/groups/theme/default-grassland-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# GRASSLAND +# MONOBIOME :mode=dark :harshness=default +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-grassland-monobiome-light.toml b/templates/groups/theme/default-grassland-monobiome-light.toml index 43c68f5..1b4eda7 100644 --- a/templates/groups/theme/default-grassland-monobiome-light.toml +++ b/templates/groups/theme/default-grassland-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# GRASSLAND +# MONOBIOME :mode=light :harshness=default +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/default-savanna-monobiome-dark.toml b/templates/groups/theme/default-savanna-monobiome-dark.toml index c9fd601..fff681f 100644 --- a/templates/groups/theme/default-savanna-monobiome-dark.toml +++ b/templates/groups/theme/default-savanna-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# SAVANNA +# MONOBIOME :mode=dark :harshness=default +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-savanna-monobiome-light.toml b/templates/groups/theme/default-savanna-monobiome-light.toml index 5e10664..18ac116 100644 --- a/templates/groups/theme/default-savanna-monobiome-light.toml +++ b/templates/groups/theme/default-savanna-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# SAVANNA +# MONOBIOME :mode=light :harshness=default +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/default-tundra-monobiome-dark.toml b/templates/groups/theme/default-tundra-monobiome-dark.toml index 2576095..74c9b4f 100644 --- a/templates/groups/theme/default-tundra-monobiome-dark.toml +++ b/templates/groups/theme/default-tundra-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=default -# TUNDRA +# MONOBIOME :mode=dark :harshness=default +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/default-tundra-monobiome-light.toml b/templates/groups/theme/default-tundra-monobiome-light.toml index 57fd2a9..49b700f 100644 --- a/templates/groups/theme/default-tundra-monobiome-light.toml +++ b/templates/groups/theme/default-tundra-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=default -# TUNDRA +# MONOBIOME :mode=light :harshness=default +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-alpine-monobiome-dark.toml b/templates/groups/theme/hard-alpine-monobiome-dark.toml index eb8174c..adabacd 100644 --- a/templates/groups/theme/hard-alpine-monobiome-dark.toml +++ b/templates/groups/theme/hard-alpine-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# ALPINE +# MONOBIOME :mode=dark :harshness=hard +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-alpine-monobiome-light.toml b/templates/groups/theme/hard-alpine-monobiome-light.toml index 590f646..e023cdf 100644 --- a/templates/groups/theme/hard-alpine-monobiome-light.toml +++ b/templates/groups/theme/hard-alpine-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# ALPINE +# MONOBIOME :mode=light :harshness=hard +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-badlands-monobiome-dark.toml b/templates/groups/theme/hard-badlands-monobiome-dark.toml index 1c78c46..cff88f2 100644 --- a/templates/groups/theme/hard-badlands-monobiome-dark.toml +++ b/templates/groups/theme/hard-badlands-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# BADLANDS +# MONOBIOME :mode=dark :harshness=hard +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-badlands-monobiome-light.toml b/templates/groups/theme/hard-badlands-monobiome-light.toml index c27c209..9185ee2 100644 --- a/templates/groups/theme/hard-badlands-monobiome-light.toml +++ b/templates/groups/theme/hard-badlands-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# BADLANDS +# MONOBIOME :mode=light :harshness=hard +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-chaparral-monobiome-dark.toml b/templates/groups/theme/hard-chaparral-monobiome-dark.toml index 90688ef..80f67c2 100644 --- a/templates/groups/theme/hard-chaparral-monobiome-dark.toml +++ b/templates/groups/theme/hard-chaparral-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# CHAPARRAL +# MONOBIOME :mode=dark :harshness=hard +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-chaparral-monobiome-light.toml b/templates/groups/theme/hard-chaparral-monobiome-light.toml index 30176a5..26a11a2 100644 --- a/templates/groups/theme/hard-chaparral-monobiome-light.toml +++ b/templates/groups/theme/hard-chaparral-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# CHAPARRAL +# MONOBIOME :mode=light :harshness=hard +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-grassland-monobiome-dark.toml b/templates/groups/theme/hard-grassland-monobiome-dark.toml index 727c9bc..67695b9 100644 --- a/templates/groups/theme/hard-grassland-monobiome-dark.toml +++ b/templates/groups/theme/hard-grassland-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# GRASSLAND +# MONOBIOME :mode=dark :harshness=hard +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-grassland-monobiome-light.toml b/templates/groups/theme/hard-grassland-monobiome-light.toml index 1e3a658..b3549e7 100644 --- a/templates/groups/theme/hard-grassland-monobiome-light.toml +++ b/templates/groups/theme/hard-grassland-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# GRASSLAND +# MONOBIOME :mode=light :harshness=hard +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-savanna-monobiome-dark.toml b/templates/groups/theme/hard-savanna-monobiome-dark.toml index c90dcda..83ddc64 100644 --- a/templates/groups/theme/hard-savanna-monobiome-dark.toml +++ b/templates/groups/theme/hard-savanna-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# SAVANNA +# MONOBIOME :mode=dark :harshness=hard +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-savanna-monobiome-light.toml b/templates/groups/theme/hard-savanna-monobiome-light.toml index ee87306..6a0df39 100644 --- a/templates/groups/theme/hard-savanna-monobiome-light.toml +++ b/templates/groups/theme/hard-savanna-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# SAVANNA +# MONOBIOME :mode=light :harshness=hard +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/hard-tundra-monobiome-dark.toml b/templates/groups/theme/hard-tundra-monobiome-dark.toml index 5e8e461..983660f 100644 --- a/templates/groups/theme/hard-tundra-monobiome-dark.toml +++ b/templates/groups/theme/hard-tundra-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=hard -# TUNDRA +# MONOBIOME :mode=dark :harshness=hard +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/hard-tundra-monobiome-light.toml b/templates/groups/theme/hard-tundra-monobiome-light.toml index ffae463..2352364 100644 --- a/templates/groups/theme/hard-tundra-monobiome-light.toml +++ b/templates/groups/theme/hard-tundra-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=hard -# TUNDRA +# MONOBIOME :mode=light :harshness=hard +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-alpine-monobiome-dark.toml b/templates/groups/theme/soft-alpine-monobiome-dark.toml index f808163..dcb3f38 100644 --- a/templates/groups/theme/soft-alpine-monobiome-dark.toml +++ b/templates/groups/theme/soft-alpine-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# ALPINE +# MONOBIOME :mode=soft :harshness=hard +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-alpine-monobiome-light.toml b/templates/groups/theme/soft-alpine-monobiome-light.toml index 6e98d68..3be8cff 100644 --- a/templates/groups/theme/soft-alpine-monobiome-light.toml +++ b/templates/groups/theme/soft-alpine-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# ALPINE +# MONOBIOME :mode=light :harshness=soft +# ALPINE :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-badlands-monobiome-dark.toml b/templates/groups/theme/soft-badlands-monobiome-dark.toml index 181a61f..3cfcbb6 100644 --- a/templates/groups/theme/soft-badlands-monobiome-dark.toml +++ b/templates/groups/theme/soft-badlands-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# BADLANDS +# MONOBIOME :mode=dark :harshness=soft +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-badlands-monobiome-light.toml b/templates/groups/theme/soft-badlands-monobiome-light.toml index f43ba14..287e87c 100644 --- a/templates/groups/theme/soft-badlands-monobiome-light.toml +++ b/templates/groups/theme/soft-badlands-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# BADLANDS +# MONOBIOME :mode=light :harshness=soft +# BADLANDS :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-chaparral-monobiome-dark.toml b/templates/groups/theme/soft-chaparral-monobiome-dark.toml index 4db134d..29e40c8 100644 --- a/templates/groups/theme/soft-chaparral-monobiome-dark.toml +++ b/templates/groups/theme/soft-chaparral-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# CHAPARRAL +# MONOBIOME :mode=dark :harshness=soft +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-chaparral-monobiome-light.toml b/templates/groups/theme/soft-chaparral-monobiome-light.toml index 6b32b28..5b54246 100644 --- a/templates/groups/theme/soft-chaparral-monobiome-light.toml +++ b/templates/groups/theme/soft-chaparral-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# CHAPARRAL +# MONOBIOME :mode=light :harshness=soft +# CHAPARRAL :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-grassland-monobiome-dark.toml b/templates/groups/theme/soft-grassland-monobiome-dark.toml index ea40708..ba60eb0 100644 --- a/templates/groups/theme/soft-grassland-monobiome-dark.toml +++ b/templates/groups/theme/soft-grassland-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# GRASSLAND +# MONOBIOME :mode=dark :harshness=soft +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-grassland-monobiome-light.toml b/templates/groups/theme/soft-grassland-monobiome-light.toml index 84cf154..8ed96aa 100644 --- a/templates/groups/theme/soft-grassland-monobiome-light.toml +++ b/templates/groups/theme/soft-grassland-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# GRASSLAND +# MONOBIOME :mode=light :harshness=soft +# GRASSLAND :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-savanna-monobiome-dark.toml b/templates/groups/theme/soft-savanna-monobiome-dark.toml index 475fe55..a699ce5 100644 --- a/templates/groups/theme/soft-savanna-monobiome-dark.toml +++ b/templates/groups/theme/soft-savanna-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# SAVANNA +# MONOBIOME :mode=dark :harshness=soft +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-savanna-monobiome-light.toml b/templates/groups/theme/soft-savanna-monobiome-light.toml index a239ba2..0619d48 100644 --- a/templates/groups/theme/soft-savanna-monobiome-light.toml +++ b/templates/groups/theme/soft-savanna-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# SAVANNA +# MONOBIOME :mode=light :harshness=soft +# SAVANNA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65 diff --git a/templates/groups/theme/soft-tundra-monobiome-dark.toml b/templates/groups/theme/soft-tundra-monobiome-dark.toml index cfba9f1..91df3ca 100644 --- a/templates/groups/theme/soft-tundra-monobiome-dark.toml +++ b/templates/groups/theme/soft-tundra-monobiome-dark.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=dark :contrast=soft -# TUNDRA +# MONOBIOME :mode=dark :harshness=soft +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: min -- +15 | +30 | +40 | +50 -- +65 diff --git a/templates/groups/theme/soft-tundra-monobiome-light.toml b/templates/groups/theme/soft-tundra-monobiome-light.toml index 7258a62..f97bc19 100644 --- a/templates/groups/theme/soft-tundra-monobiome-light.toml +++ b/templates/groups/theme/soft-tundra-monobiome-light.toml @@ -1,6 +1,6 @@ # - META ------------------------------------- -# MONOBIOME :mode=light :contrast=soft -# TUNDRA +# MONOBIOME :mode=light :harshness=soft +# TUNDRA :contrast=WCAG 2.2 AA # # pat :: < 0-bg-3 > | gra | acc | < 3-fg-0 > # abs :: max -- -15 | -30 | -40 | -50 -- -65